Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "emit_load_locked", "(", "enum", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_load_locked_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_load_locked_di", ";", "emit_insn", "(", "fn", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "load-locked", "instruction", "in", "MODE", ".", "For", "QI/HImode", ",", "possibly", "use", "a", "pattern", "than", "includes", "the", "zero_extend", "operation", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "default", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "return", "false", ";", "}", "unsigned", "Paired", "=", "Hint", ".", "second", ";", "if", "(", "Paired", "==", "0", ")", "return", "false", ";", "unsigned", "PairedPhys", "=", "0", ";", "if", "(", "Register", "::", "isPhysicalRegister", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "Paired", ";", "}", "else", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Paired", ")", ",", "Odd", ",", "this", ")", ";", "}", "if", "(", "PairedPhys", "&&", "is_contained", "(", "Order", ",", "PairedPhys", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "unsigned", "Reg", ":", "Order", ")", "{", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "unsigned", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "ARM", "ARM", "ARMRI::RegPairEven", "0", "ARMRI::RegPairOdd", "1", "0", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "DLXInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", ",", "0u", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "DLX", "DLX", "0u" ]

[]

[ "<s>", "static", "void", "rx_get_stack_layout", "(", "unsigned", "int", "*", "lowest", ",", "unsigned", "int", "*", "highest", ",", "unsigned", "int", "*", "register_mask", ",", "unsigned", "int", "*", "frame_size", ",", "unsigned", "int", "*", "stack_size", ")", "{", "unsigned", "int", "reg", ";", "unsigned", "int", "low", ";", "unsigned", "int", "high", ";", "unsigned", "int", "fixed_reg", "=", "0", ";", "unsigned", "int", "save_mask", ";", "unsigned", "int", "pushed_mask", ";", "unsigned", "int", "unneeded_pushes", ";", "if", "(", "is_naked_func", "(", "NULL_TREE", ")", ")", "{", "*", "lowest", "=", "0", ";", "*", "highest", "=", "0", ";", "*", "register_mask", "=", "0", ";", "*", "frame_size", "=", "0", ";", "*", "stack_size", "=", "0", ";", "return", ";", "}", "for", "(", "save_mask", "=", "high", "=", "low", "=", "0", ",", "reg", "=", "1", ";", "reg", "<", "CC_REGNUM", ";", "reg", "++", ")", "{", "if", "(", "(", "df_regs_ever_live_p", "(", "reg", ")", "||", "(", "call_used_or_fixed_reg_p", "(", "reg", ")", "&&", "is_interrupt_func", "(", "NULL_TREE", ")", "&&", "!", "crtl", "->", "is_leaf", ")", ")", "&&", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", "||", "is_interrupt_func", "(", "NULL_TREE", ")", "||", "(", "is_fast_interrupt_func", "(", "NULL_TREE", ")", "&&", "!", "IN_RANGE", "(", "reg", ",", "10", ",", "13", ")", ")", ")", ")", "{", "if", "(", "low", "==", "0", ")", "low", "=", "reg", ";", "high", "=", "reg", ";", "save_mask", "|=", "1", "<<", "reg", ";", "}", "if", "(", "low", "!=", "0", "&&", "fixed_reg", "==", "0", "&&", "fixed_regs", "[", "reg", "]", ")", "fixed_reg", "=", "reg", ";", "}", "if", "(", "MUST_SAVE_ACC_REGISTER", "&&", "bit_count", "(", "save_mask", ")", "<", "2", ")", "{", "save_mask", "|=", "(", "1", "<<", "13", ")", "|", "(", "1", "<<", "14", ")", ";", "if", "(", "low", "==", "0", ")", "low", "=", "13", ";", "if", "(", "high", "==", "0", "||", "low", "==", "high", ")", "high", "=", "low", "+", "1", ";", "}", "pushed_mask", "=", "(", "HOST_WIDE_INT_M1U", "<<", "low", ")", "&", "~", "(", "HOST_WIDE_INT_M1U", "<<", "(", "high", "+", "1", ")", ")", ";", "unneeded_pushes", "=", "(", "pushed_mask", "&", "(", "~", "save_mask", ")", ")", "&", "pushed_mask", ";", "if", "(", "(", "fixed_reg", "&&", "fixed_reg", "<=", "high", ")", "||", "(", "optimize_function_for_speed_p", "(", "cfun", ")", "&&", "bit_count", "(", "save_mask", ")", "<", "bit_count", "(", "unneeded_pushes", ")", ")", ")", "{", "*", "lowest", "=", "0", ";", "*", "highest", "=", "0", ";", "*", "register_mask", "=", "save_mask", ";", "}", "else", "{", "*", "lowest", "=", "low", ";", "*", "highest", "=", "high", ";", "*", "register_mask", "=", "0", ";", "}", "*", "frame_size", "=", "rx_round_up", "(", "get_frame_size", "(", ")", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "crtl", "->", "args", ".", "size", ">", "0", ")", "*", "frame_size", "+=", "rx_round_up", "(", "crtl", "->", "args", ".", "size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "*", "stack_size", "=", "rx_round_up", "(", "crtl", "->", "outgoing_args_size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "Returns", "either", "the", "lowest", "numbered", "and", "highest", "numbered", "registers", "that", "occupy", "the", "call-saved", "area", "of", "the", "stack", "frame", ",", "if", "the", "registers", "are", "stored", "as", "a", "contiguous", "block", ",", "or", "else", "a", "bitmask", "of", "the", "individual", "registers", "if", "they", "are", "stored", "piecemeal", ".", "Also", "computes", "the", "size", "of", "the", "frame", "and", "the", "size", "of", "the", "outgoing", "arguments", "block", "(", "in", "bytes", ")", "." ]

[ "rx", "0", "0", "0", "0", "0", "0", "0", "1", "10", "13", "0", "1", "0", "0", "2", "1", "13", "1", "14", "0", "13", "0", "1", "1", "0", "0", "0", "0" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "NVPTXRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARM64AdvSIMDScalar", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** ARM64AdvSIMDScalar *****\\n\"", ")", ";", "const", "TargetMachine", "&", "TM", "=", "mf", ".", "getTarget", "(", ")", ";", "MRI", "=", "&", "mf", ".", "getRegInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "mf", ".", "begin", "(", ")", ",", "E", "=", "mf", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "processMachineBasicBlock", "(", "I", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"***** ARM64AdvSIMDScalar *****\\n\"", "ARM64" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "HexagonMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "return", "MFI", "->", "hasCalls", "(", ")", "||", "MFI", "->", "getStackSize", "(", ")", ">", "0", "||", "FuncInfo", "->", "hasClobberLR", "(", ")", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "int", "X86InstrInfo", "::", "getSPAdjust", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "getCallFrameSetupOpcode", "(", ")", "||", "MI", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "unsigned", "StackAlign", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "int", "SPAdj", "=", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "SPAdj", "-=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "getCallFrameSetupOpcode", "(", ")", ")", "return", "SPAdj", ";", "else", "return", "-", "SPAdj", ";", "}", "if", "(", "MI", "->", "isCall", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "auto", "I", "=", "++", "MachineBasicBlock", "::", "const_iterator", "(", "MI", ")", ";", "for", "(", "auto", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", "||", "I", "->", "isCall", "(", ")", ")", "break", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "getCallFrameDestroyOpcode", "(", ")", ")", "return", "0", ";", "return", "-", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "}", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "PUSH32i8", ":", "case", "X86", "::", "PUSH32r", ":", "case", "X86", "::", "PUSH32rmm", ":", "case", "X86", "::", "PUSH32rmr", ":", "case", "X86", "::", "PUSHi32", ":", "return", "4", ";", "}", "}", "</s>" ]

[ "getSPAdjust", "-", "This", "returns", "the", "stack", "pointer", "adjustment", "made", "by", "this", "instruction", "." ]

[ "X86", "X86", "0", "1", "1", "0", "1", "0", "X86::PUSH32i8", "X86::PUSH32r", "X86::PUSH32rmm", "X86::PUSH32rmr", "X86::PUSHi32", "4" ]

[]

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

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

[ "LoongArch" ]

[]

[ "<s>", "const", "uint16_t", "*", "AVRRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", "->", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "return", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "CSR_Interrupts_SaveList", ":", "CSR_Normal_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "alpha_split_tmode_pair", "(", "rtx", "operands", "[", "4", "]", ",", "machine_mode", "mode", ",", "bool", "fixup_overlap", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "CASE_CONST_SCALAR_INT", ":", "case", "CONST_DOUBLE", ":", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "fixup_overlap", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "3", "]", ")", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "}", "</s>" ]

[ "Split", "a", "TImode", "or", "TFmode", "move", "from", "OP", "[", "1", "]", "to", "OP", "[", "0", "]", "into", "a", "pair", "of", "DImode", "moves", "from", "OP", "[", "2,3", "]", "to", "OP", "[", "0,1", "]", ".", "If", "FIXUP_OVERLAP", "is", "true", ",", "guarantee", "that", "the", "sequence", "set", "(", "OP", "[", "0", "]", "OP", "[", "2", "]", ")", "set", "(", "OP", "[", "1", "]", "OP", "[", "3", "]", ")", "is", "valid", ".", "Naturally", ",", "output", "operand", "ordering", "is", "little-endian", ".", "This", "is", "used", "by", "*", "movtf_internal", "and", "*", "movti_internal", "." ]

[ "alpha", "4", "1", "3", "1", "1", "2", "1", "3", "1", "8", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "8", "0", "0", "0", "0", "3", "0", "1", "2", "3" ]

[]

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

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

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

[]

[ "<s>", "void", "PatmosInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "Patmos", "::", "MOV", ";", "}", "else", "if", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "Patmos", "::", "MOVpr", ";", "}", "else", "if", "(", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "Patmos", "::", "MOVrp", ";", "}", "else", "if", "(", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "Patmos", "::", "PMOV", ";", "}", "else", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "Opc", "=", "Patmos", "::", "MTS", ";", "}", "else", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "assert", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ";", "Opc", "=", "Patmos", "::", "MFS", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "auto", "&", "instr", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::RRegsRegClass", "Patmos::MOV", "Patmos::RRegsRegClass", "Patmos::PRegsRegClass", "Patmos::MOVpr", "Patmos::PRegsRegClass", "Patmos::RRegsRegClass", "Patmos::MOVrp", "Patmos::PRegsRegClass", "Patmos::PMOV", "Patmos::SRegsRegClass", "Patmos::RRegsRegClass", "Patmos::MTS", "Patmos::SRegsRegClass", "Patmos::RRegsRegClass", "Patmos::MFS", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "static", "void", "mips_sim_wait_units", "(", "struct", "mips_sim", "*", "state", ",", "rtx_insn", "*", "insn", ")", "{", "state_t", "tmp_state", ";", "tmp_state", "=", "alloca", "(", "state_size", "(", ")", ")", ";", "while", "(", "state", "->", "insns_left", "==", "0", "||", "(", "memcpy", "(", "tmp_state", ",", "state", "->", "dfa_state", ",", "state_size", "(", ")", ")", ",", "state_transition", "(", "tmp_state", ",", "insn", ")", ">=", "0", ")", ")", "mips_sim_next_cycle", "(", "state", ")", ";", "}", "</s>" ]

[ "Advance", "simulation", "state", "STATE", "until", "the", "units", "required", "by", "instruction", "INSN", "are", "available", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_real_tls_symbol_ref_p", "(", "rtx", "x", ")", "{", "return", "(", "SYMBOL_REF_P", "(", "x", ")", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ">=", "TLS_MODEL_REAL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "symbol", "that", "refers", "to", "real", "(", "rather", "than", "emulated", ")", "TLS", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "c6x_function_in_section_p", "(", "tree", "decl", ",", "section", "*", "section", ")", "{", "if", "(", "!", "TREE_STATIC", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "DECL_SECTION_NAME", "(", "decl", ")", ")", "{", "if", "(", "flag_function_sections", "||", "DECL_COMDAT_GROUP", "(", "decl", ")", ")", "return", "false", ";", "}", "return", "function_section", "(", "decl", ")", "==", "section", ";", "}", "</s>" ]

[ "Return", "true", "if", "DECL", "is", "known", "to", "be", "linked", "into", "section", "SECTION", "." ]

[ "c6x" ]

[]

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

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

[ "UPT" ]

[]

[ "<s>", "int", "direct_return", "(", ")", "{", "if", "(", "reload_completed", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "info", "->", "first_gp_reg_save", "==", "32", "&&", "info", "->", "first_fp_reg_save", "==", "64", "&&", "info", "->", "first_altivec_reg_save", "==", "LAST_ALTIVEC_REGNO", "+", "1", "&&", "!", "info", "->", "lr_save_p", "&&", "!", "info", "->", "cr_save_p", "&&", "info", "->", "vrsave_mask", "==", "0", "&&", "!", "info", "->", "push_p", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

[ "rs6000", "32", "64", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "tree", "h8300_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "h8300", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "void", "BPFTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ",", "bool", "DebugPassManager", ")", "{", "PB", ".", "registerPipelineStartEPCallback", "(", "[", "=", "]", "(", "ModulePassManager", "&", "MPM", ")", "{", "FunctionPassManager", "FPM", "(", "DebugPassManager", ")", ";", "FPM", ".", "addPass", "(", "BPFAbstractMemberAccessPass", "(", "this", ")", ")", ";", "FPM", ".", "addPass", "(", "BPFPreserveDITypePass", "(", ")", ")", ";", "MPM", ".", "addPass", "(", "createModuleToFunctionPassAdaptor", "(", "std", "::", "move", "(", "FPM", ")", ")", ")", ";", "}", ")", ";", "PB", ".", "registerPeepholeEPCallback", "(", "[", "=", "]", "(", "FunctionPassManager", "&", "FPM", ",", "PassBuilder", "::", "OptimizationLevel", "Level", ")", "{", "FPM", ".", "addPass", "(", "SimplifyCFGPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Invoke", "the", "PassBuilder", "callback", "registration", "." ]

[ "BPF", "BPF", "BPF", "BPF" ]

[]

[ "<s>", "static", "cpp_hashnode", "*", "s390_categorize_keyword", "(", "const", "cpp_token", "*", "tok", ")", "{", "if", "(", "tok", "->", "type", "==", "CPP_NAME", ")", "{", "cpp_hashnode", "*", "ident", "=", "tok", "->", "val", ".", "node", ".", "node", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "vector_keyword", ")", ")", "return", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "bool_keyword", ")", ")", "return", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "_Bool_keyword", ")", ")", "return", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ";", "return", "ident", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Unify", "the", "different", "variants", "to", "the", "same", "nodes", "in", "order", "to", "keep", "the", "code", "working", "with", "it", "simple", "." ]

[ "s390", "0" ]

[]

[ "<s>", "static", "bool", "mips_rewrite_small_data_p", "(", "rtx", "x", ")", "{", "enum", "mips_symbol_type", "symbol_type", ";", "return", "(", "TARGET_EXPLICIT_RELOCS", "&&", "mips_symbolic_constant_p", "(", "x", ",", "&", "symbol_type", ")", "&&", "symbol_type", "==", "SYMBOL_SMALL_DATA", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "small", "data", "address", "that", "can", "be", "rewritten", "as", "a", "LO_SUM", "." ]

[ "mips" ]

[]

[ "<s>", "ChangeStatus", "manifest", "(", "Attributor", "&", "A", ")", "override", "{", "SmallVector", "<", "Attribute", ",", "8", ">", "AttrList", ";", "LLVMContext", "&", "Ctx", "=", "getAssociatedFunction", "(", ")", "->", "getContext", "(", ")", ";", "for", "(", "StringRef", "AttrName", ":", "Attributes", ")", "AttrList", ".", "push_back", "(", "Attribute", "::", "get", "(", "Ctx", ",", "AttrName", ")", ")", ";", "return", "IRAttributeManifest", "::", "manifestAttrs", "(", "A", ",", "getIRPosition", "(", ")", ",", "AttrList", ",", "true", ")", ";", "}", "</s>" ]

[ "See", "AbstractAttribute", ":", ":manifest", "(", "...", ")", "." ]

[ "AMDGPU", "8" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "pdp11_assemble_shift", "(", "rtx", "*", "operands", ",", "machine_mode", "m", ",", "int", "code", ")", "{", "int", "i", ",", "n", ";", "rtx", "inops", "[", "2", "]", ";", "rtx", "exops", "[", "2", "]", "[", "2", "]", ";", "rtx", "lb", "[", "1", "]", ";", "pdp11_action", "action", "[", "2", "]", ";", "const", "bool", "small", "=", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "&&", "pdp11_small_shift", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "gcc_assert", "(", "small", "||", "!", "TARGET_40_PLUS", ")", ";", "if", "(", "m", "==", "E_SImode", ")", "{", "inops", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "pdp11_expand_operands", "(", "inops", ",", "exops", ",", "1", ",", "2", ",", "action", ",", "either", ")", ";", "}", "if", "(", "!", "small", ")", "{", "lb", "[", "0", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_label", "(", "lb", "[", "0", "]", ")", ";", "fputs", "(", "\":\\n\"", ",", "asm_out_file", ")", ";", "n", "=", "1", ";", "}", "else", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "code", "==", "LSHIFTRT", ")", "{", "output_asm_insn", "(", "\"clc\"", ",", "NULL", ")", ";", "switch", "(", "m", ")", "{", "case", "E_QImode", ":", "output_asm_insn", "(", "\"rorb\\t%0\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "output_asm_insn", "(", "\"ror\\t%0\"", ",", "operands", ")", ";", "break", ";", "case", "E_SImode", ":", "output_asm_insn", "(", "\"ror\\t%0\"", ",", "exops", "[", "0", "]", ")", ";", "output_asm_insn", "(", "\"ror\\t%0\"", ",", "exops", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "n", "--", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "switch", "(", "code", ")", "{", "case", "LSHIFTRT", ":", "case", "ASHIFTRT", ":", "switch", "(", "m", ")", "{", "case", "E_QImode", ":", "output_asm_insn", "(", "\"asrb\\t%0\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "output_asm_insn", "(", "\"asr\\t%0\"", ",", "operands", ")", ";", "break", ";", "case", "E_SImode", ":", "output_asm_insn", "(", "\"asr\\t%0\"", ",", "exops", "[", "0", "]", ")", ";", "output_asm_insn", "(", "\"ror\\t%0\"", ",", "exops", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "ASHIFT", ":", "switch", "(", "m", ")", "{", "case", "E_QImode", ":", "output_asm_insn", "(", "\"aslb\\t%0\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "output_asm_insn", "(", "\"asl\\t%0\"", ",", "operands", ")", ";", "break", ";", "case", "E_SImode", ":", "output_asm_insn", "(", "\"asl\\t%0\"", ",", "exops", "[", "1", "]", ")", ";", "output_asm_insn", "(", "\"rol\\t%0\"", ",", "exops", "[", "0", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "}", "}", "if", "(", "!", "small", ")", "{", "output_asm_insn", "(", "\"dec\\t%2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"bne\\t%l0\"", ",", "lb", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Emit", "the", "instructions", "needed", "to", "produce", "a", "shift", "by", "a", "small", "constant", "amount", "(", "unrolled", ")", ",", "or", "a", "shift", "made", "from", "a", "loop", "for", "the", "base", "machine", "case", "." ]

[ "pdp11", "2", "2", "2", "1", "2", "2", "2", "0", "0", "1", "2", "0", "0", "\":\\n\"", "1", "2", "\"clc\"", "\"rorb\\t%0\"", "\"ror\\t%0\"", "\"ror\\t%0\"", "0", "\"ror\\t%0\"", "1", "0", "\"asrb\\t%0\"", "\"asr\\t%0\"", "\"asr\\t%0\"", "0", "\"ror\\t%0\"", "1", "\"aslb\\t%0\"", "\"asl\\t%0\"", "\"asl\\t%0\"", "1", "\"rol\\t%0\"", "0", "\"dec\\t%2\"", "\"bne\\t%l0\"", "\"\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register x\"", ";", "OS", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "RISCV", "\"<register x\"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "static", "StringRef", "getFunctionName", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ")", "{", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "G", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "return", "G", "->", "getSymbol", "(", ")", ";", "}", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "return", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "}", "llvm_unreachable", "(", "\"don't know how to get the name for this callee\"", ")", ";", "}", "</s>" ]

[ "Get", "the", "entire", "name", "of", "this", "function", "." ]

[ "AVR", "\"don't know how to get the name for this callee\"" ]

[]

[ "<s>", "ARMConstantPoolSymbol", "*", "ARMConstantPoolSymbol", "::", "Create", "(", "LLVMContext", "&", "C", ",", "StringRef", "s", ",", "unsigned", "ID", ",", "unsigned", "char", "PCAdj", ")", "{", "return", "new", "ARMConstantPoolSymbol", "(", "C", ",", "s", ",", "ID", ",", "PCAdj", ",", "ARMCP", "::", "no_modifier", ",", "false", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARMCP::no_modifier" ]

[]

[ "<s>", "static", "void", "note_np_check_stores", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "REGNO", "(", "x", ")", "==", "REG_CC", "||", "(", "int", ")", "REGNO", "(", "x", ")", "==", "np_check_regno", ")", ")", "np_check_regno", "=", "-", "1", ";", "}", "</s>" ]

[ "Subroutine", "of", "workaround_speculation", ",", "called", "through", "note_stores", "." ]

[ "bfin", "1" ]

[]

[ "<s>", "static", "void", "th_mempair_restore_regs", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "set1", "=", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "rtx", "set2", "=", "gen_rtx_SET", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "rtx", "insn", "=", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set1", ",", "set2", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "operands", "[", "0", "]", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "operands", "[", "2", "]", ")", ";", "}", "</s>" ]

[ "Similar", "like", "riscv_restore_reg", ",", "but", "restores", "two", "registers", "from", "memory", "and", "marks", "the", "instruction", "frame-related", "." ]

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

[]

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

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

[ "SPIRV" ]

[]

[ "<s>", "void", "TPCSchedStrategy", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "(", "void", ")", "MI", ";", "if", "(", "SU", "->", "isScheduled", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** release Top - already scheduled: \"", "<<", "*", "MI", ")", ";", "return", ";", "}", "SU", "->", "TopReadyCycle", "=", "0", ";", "for", "(", "const", "SDep", "&", "PI", ":", "SU", "->", "Preds", ")", "{", "unsigned", "PredReadyCycle", "=", "PI", ".", "getSUnit", "(", ")", "->", "TopReadyCycle", ";", "unsigned", "MinLatency", "=", "PI", ".", "getLatency", "(", ")", ";", "Top", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Top", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "TopReadyCycle", "<", "PredReadyCycle", "+", "MinLatency", ")", "SU", "->", "TopReadyCycle", "=", "PredReadyCycle", "+", "MinLatency", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** released Top (ready = \"", "<<", "SU", "->", "TopReadyCycle", "<<", "\"): \"", "<<", "*", "MI", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TPC", "::", "MOVnodce", ")", "{", "SU", "->", "isScheduleHigh", "=", "true", ";", "}", "Top", ".", "releaseNode", "(", "SU", ",", "SU", "->", "TopReadyCycle", ",", "isPostRA", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "TPC", "TPC", "\"*** release Top - already scheduled: \"", "0", "\"*** released Top (ready = \"", "\"): \"", "TPC::MOVnodce" ]

[]

[ "<s>", "enum", "reg_class", "m68k_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "enum", "reg_class", "secondary_class", ";", "secondary_class", "=", "m68k_secondary_reload_class", "(", "rclass", ",", "GET_MODE", "(", "x", ")", ",", "x", ")", ";", "if", "(", "secondary_class", "!=", "NO_REGS", "&&", "reg_class_subset_p", "(", "secondary_class", ",", "rclass", ")", ")", "return", "secondary_class", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "reg_class_subset_p", "(", "DATA_REGS", ",", "rclass", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "-", "0x80", ",", "0x7f", ")", ")", "return", "DATA_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "if", "(", "TARGET_HARD_FLOAT", "&&", "reg_class_subset_p", "(", "FP_REGS", ",", "rclass", ")", ")", "return", "FP_REGS", ";", "return", "NO_REGS", ";", "}", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "PREFERRED_RELOAD_CLASS", "." ]

[ "m68k", "0x80", "0x7f" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "getReturnCC", "(", "CallConv", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "\"Unexpected custom lowering\"", ")", ";", "SDValue", "OutVal", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f32", ")", ";", "SDValue", "Undef", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "DL", ",", "MVT", "::", "i64", ")", ",", "0", ")", ";", "SDValue", "Sub_f32", "=", "DAG", ".", "getTargetConstant", "(", "VE", "::", "sub_f32", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "OutVal", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "INSERT_SUBREG", ",", "DL", ",", "MVT", "::", "i64", ",", "Undef", ",", "OutVal", ",", "Sub_f32", ")", ",", "0", ")", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVal", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "VEISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "ISD::OutputArg", "16", "4", "1", "0", "\"Can only return in registers!\"", "\"Unexpected custom lowering\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "MVT::i64", "MVT::f32", "MVT::i64", "0", "VE::sub_f32", "MVT::i32", "MVT::i64", "0", "\"Unknown loc info!\"", "1", "0", "VEISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "void", "pa_output_addr_diff_vec", "(", "rtx", "lab", ",", "rtx", "body", ")", "{", "rtx", "base", "=", "XEXP", "(", "XEXP", "(", "body", ",", "0", ")", ",", "0", ")", ";", "int", "idx", ",", "vlen", "=", "XVECLEN", "(", "body", ",", "1", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "lab", ")", ")", ";", "if", "(", "TARGET_GAS", ")", "fputs", "(", "\"\\t.begin_brtab\\n\"", ",", "asm_out_file", ")", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "ASM_OUTPUT_ADDR_DIFF_ELT", "(", "asm_out_file", ",", "body", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XVECEXP", "(", "body", ",", "1", ",", "idx", ")", ",", "0", ")", ")", ",", "CODE_LABEL_NUMBER", "(", "base", ")", ")", ";", "}", "if", "(", "TARGET_GAS", ")", "fputs", "(", "\"\\t.end_brtab\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "address", "difference", "vector", "." ]

[ "pa", "0", "0", "1", "\"L\"", "\"\\t.begin_brtab\\n\"", "0", "1", "0", "\"\\t.end_brtab\\n\"" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "RA", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "RA_64", ":", "Mips", "::", "RA", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "BP", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "S7_64", ":", "Mips", "::", "S7", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "RA", ")", ";", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "FP", ")", ";", "}", "if", "(", "hasBP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "BP", ")", ";", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "MipsFI", "->", "createEhDataRegsFI", "(", ")", ";", "if", "(", "MipsFI", "->", "isISR", "(", ")", ")", "MipsFI", "->", "createISRRegFI", "(", ")", ";", "if", "(", "ExpandPseudo", "(", "MF", ")", ".", "expand", "(", ")", ")", "{", "const", "TargetRegisterClass", "&", "RC", "=", "STI", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "uint64_t", "MaxSPOffset", "=", "estimateStackSize", "(", "MF", ")", ";", "if", "(", "isIntN", "(", "STI", ".", "hasMSA", "(", ")", "?", "10", ":", "16", ",", "MaxSPOffset", ")", "&&", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "return", ";", "const", "TargetRegisterClass", "&", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::RA_64", "Mips::RA", "Mips::S7_64", "Mips::S7", "Mips", "Mips", "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "10", "16", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "int", "AArch64AsmParser", "::", "tryParseRegister", "(", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "-", "1", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "if", "(", "isSVEDataVectorRegister", "(", "lowerCase", ")", ")", "return", "-", "1", ";", "unsigned", "RegNum", "=", "matchRegisterNameAlias", "(", "lowerCase", ",", "RegKind", "::", "Scalar", ")", ";", "if", "(", "RegNum", "==", "0", ")", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"fp\"", ",", "AArch64", "::", "FP", ")", ".", "Case", "(", "\"lr\"", ",", "AArch64", "::", "LR", ")", ".", "Case", "(", "\"x31\"", ",", "AArch64", "::", "XZR", ")", ".", "Case", "(", "\"w31\"", ",", "AArch64", "::", "WZR", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "RegNum", "==", "0", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "AArch64", "AArch64", "1", "1", "0", "\"fp\"", "AArch64::FP", "\"lr\"", "AArch64::LR", "\"x31\"", "AArch64::XZR", "\"w31\"", "AArch64::WZR", "0", "0", "1" ]

[]

[ "<s>", "static", "rtx", "mmix_function_arg", "(", "cumulative_args_t", "argsp", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "return", "mmix_function_arg_1", "(", "argsp", ",", "mode", ",", "type", ",", "named", ",", "false", ")", ";", "}", "</s>" ]

[ "Return", "an", "rtx", "for", "a", "function", "argument", "to", "go", "in", "a", "register", ",", "and", "0", "for", "one", "that", "must", "go", "on", "stack", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "addDomain", "(", "unsigned", "domain", ")", "{", "AvailableDomains", "|=", "1u", "<<", "domain", ";", "}", "</s>" ]

[ "Mark", "domain", "as", "available", "." ]

[ "X86", "1u" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ";", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "TargetMachine", "&", "TM", "=", "F", ".", "getTarget", "(", ")", ";", "IsPIC", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "ABI", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ";", "LongBranchSeqSize", "=", "!", "IsPIC", "?", "2", ":", "(", "ABI", ".", "IsN64", "(", ")", "?", "10", ":", "(", "!", "STI", ".", "isTargetNaCl", "(", ")", "?", "9", ":", "10", ")", ")", ";", "if", "(", "STI", ".", "inMips16Mode", "(", ")", "||", "!", "STI", ".", "enableLongBranchPass", "(", ")", ")", "return", "false", ";", "if", "(", "IsPIC", "&&", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "int", "ShVal", "=", "STI", ".", "inMicroMipsMode", "(", ")", "?", "2", ":", "4", ";", "int64_t", "Offset", "=", "computeOffset", "(", "I", "->", "Br", ")", "/", "ShVal", ";", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "{", "Offset", "*=", "2", ";", "}", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "IsPIC", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "2", "10", "9", "10", "Mips", "Mips", "Mips", "Mips", "2", "4", "2", "16", "4", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "AArch64TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "AArch64PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreLegalizeMachineIR", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "addPass", "(", "createAMDGPUPreLegalizeCombiner", "(", "IsOptNone", ")", ")", ";", "addPass", "(", "new", "Localizer", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "MachineInstrBuilder", "buildLoad", "(", "const", "DstOp", "&", "Res", ",", "const", "CCValAssign", "&", "VA", ")", "{", "MachineMemOperand", "*", "MMO", ";", "Register", "Addr", "=", "getStackAddress", "(", "VA", ",", "MMO", ")", ";", "return", "MIRBuilder", ".", "buildLoad", "(", "Res", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "encodeVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "ConstantFP", "*", "Cnt", "=", "MO", ".", "getFPImm", "(", ")", ";", "APFloat", "Val", "=", "Cnt", "->", "getValueAPF", "(", ")", ";", "switch", "(", "Cnt", "->", "getType", "(", ")", "->", "getTypeID", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported FP type\"", ")", ";", "break", ";", "case", "Type", "::", "FloatTyID", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "NVPTXFloatMCExpr", "::", "CreateConstantFPSingle", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "case", "Type", "::", "DoubleTyID", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "NVPTXFloatMCExpr", "::", "CreateConstantFPDouble", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "}", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"unknown operand type\"", "\"Unsupported FP type\"", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "aarch64_harden_sls_blr_p", "(", "void", ")", "{", "return", "aarch64_sls_hardening", "&", "SLS_BLR", ";", "}", "</s>" ]

[ "Return", "whether", "we", "should", "mitigatate", "Straight", "Line", "Speculation", "for", "the", "BLR", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "size_t", "count", "(", "const", "StackVreg", "&", "Elem", ")", "const", "{", "return", "llvm", "::", "count", "(", "Data", ",", "Elem", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "specified", "key", "is", "in", "the", "map", ",", "0", "otherwise", "." ]

[ "TVM" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "OptForMinSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "assert", "(", "(", "!", "OptForMinSize", "||", "OptForSize", ")", "&&", "\"OptForMinSize implies OptForSize\"", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "slowTwoMemOps", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "!", "getTargetMachine", "(", ")", ".", "isPositionIndependent", "(", ")", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "moveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "TLI", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "\"OptForMinSize implies OptForSize\"", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "ISD::EXTLOAD", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'r'", ":", "break", ";", "default", ":", "return", "true", ";", "}", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "AMDGPUInstPrinter", "::", "printRegOperand", "(", "MO", ".", "getReg", "(", ")", ",", "O", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "return", "false", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "int64_t", "Val", "=", "MO", ".", "getImm", "(", ")", ";", "if", "(", "AMDGPU", "::", "isInlinableIntLiteral", "(", "Val", ")", ")", "{", "O", "<<", "Val", ";", "}", "else", "if", "(", "isUInt", "<", "16", ">", "(", "Val", ")", ")", "{", "O", "<<", "format", "(", "\"0x%\"", "PRIx16", ",", "static_cast", "<", "uint16_t", ">", "(", "Val", ")", ")", ";", "}", "else", "if", "(", "isUInt", "<", "32", ">", "(", "Val", ")", ")", "{", "O", "<<", "format", "(", "\"0x%\"", "PRIx32", ",", "static_cast", "<", "uint32_t", ">", "(", "Val", ")", ")", ";", "}", "else", "{", "O", "<<", "format", "(", "\"0x%\"", "PRIx64", ",", "static_cast", "<", "uint64_t", ">", "(", "Val", ")", ")", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "0", "1", "0", "0", "AMDGPU", "AMDGPU::isInlinableIntLiteral", "16", "\"0x%\"", "32", "\"0x%\"", "\"0x%\"" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "X86Subtarget", "::", "getRegBankInfo", "(", ")", "const", "{", "return", "RegBankInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "isReg", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ")", "{", "assert", "(", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "&&", "\"Register operand expected.\"", ")", ";", "return", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "R", ";", "}", "</s>" ]

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

[ "Mips", "\"Register operand expected.\"" ]

[]

[ "<s>", "static", "bool", "m32r_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_INT", "&&", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", ".", "Tie", "QI/HI/SI", "modes", "together", "." ]

[ "m32r" ]

[]

[ "<s>", "static", "void", "mips_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gp_saved", ",", "fp_saved", ";", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "mips_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "arg", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_gprs", ";", "fp_saved", "=", "(", "EABI_FLOAT_VARARGS_P", "?", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_fprs", ":", "0", ")", ";", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "-", "gp_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "num_gprs", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "machine_mode", "mode", ";", "int", "off", ",", "i", ";", "off", "=", "ROUND_DOWN", "(", "-", "gp_saved", "*", "UNITS_PER_WORD", ",", "UNITS_PER_FPVALUE", ")", ";", "off", "-=", "fp_saved", "*", "UNITS_PER_FPREG", ";", "mode", "=", "TARGET_SINGLE_FLOAT", "?", "SFmode", ":", "DFmode", ";", "for", "(", "i", "=", "local_cum", ".", "num_fprs", ";", "i", "<", "MAX_ARGS_IN_REGISTERS", ";", "i", "+=", "MAX_FPRS_PER_FMT", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "mips_emit_move", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "FP_ARG_FIRST", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_HWFPVALUE", ";", "}", "}", "}", "if", "(", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "==", "0", ")", "cfun", "->", "machine", "->", "varargs_size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", "+", "fp_saved", "*", "UNITS_PER_FPREG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "2", ",", "-", "4", ")", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for FPW register must be last in order to be found!\"", ")", ";", "FrameIdx", "=", "0", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "2", "4", "\"Slot for FPW register must be last in order to be found!\"", "0" ]

[]

[ "<s>", "bool", "LEGInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "LEG", "::", "MOVi32", ":", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "const", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "bool", "DstIsDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "auto", "LO16", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "LEG", "::", "MOVLOi16", ")", ",", "DstReg", ")", ";", "auto", "HI16", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "LEG", "::", "MOVHIi16", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "const", "unsigned", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "const", "unsigned", "Lo16", "=", "Imm", "&", "0xffff", ";", "const", "unsigned", "Hi16", "=", "(", "Imm", ">>", "16", ")", "&", "0xffff", ";", "LO16", "=", "LO16", ".", "addImm", "(", "Lo16", ")", ";", "HI16", "=", "HI16", ".", "addImm", "(", "Hi16", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "const", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "LO16", "=", "LO16", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "TF", "|", "LEGII", "::", "MO_LO16", ")", ";", "HI16", "=", "HI16", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "TF", "|", "LEGII", "::", "MO_HI16", ")", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "}", "}", "</s>" ]

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

[ "LEG", "LEG", "LEG::MOVi32", "0", "0", "1", "LEG::MOVLOi16", "LEG::MOVHIi16", "0xffff", "16", "0xffff", "LEGII::MO_LO16", "LEGII::MO_HI16" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "BSSSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss.large\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data.large\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataRelROSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.rodata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataRelROSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".dp.rodata.large\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ")", ";", "ReadOnlySectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.large\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ")", ";", "MergeableConst4Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst4\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "4", ",", "\"\"", ")", ";", "MergeableConst8Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst8\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "8", ",", "\"\"", ")", ";", "MergeableConst16Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst16\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "16", ",", "\"\"", ")", ";", "CStringSection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.string\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "SHF_STRINGS", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\".dp.bss\"", "\".dp.bss.large\"", "\".dp.data\"", "\".dp.data.large\"", "\".dp.rodata\"", "\".dp.rodata.large\"", "\".cp.rodata\"", "\".cp.rodata.large\"", "\".cp.rodata.cst4\"", "4", "\"\"", "\".cp.rodata.cst8\"", "8", "\"\"", "\".cp.rodata.cst16\"", "16", "\"\"", "\".cp.rodata.string\"" ]

[]

[ "<s>", "rtx", "ix86_build_const_vector", "(", "machine_mode", "mode", ",", "bool", "vect", ",", "rtx", "value", ")", "{", "int", "i", ",", "n_elt", ";", "rtvec", "v", ";", "machine_mode", "scalar_mode", ";", "switch", "(", "mode", ")", "{", "case", "E_V64QImode", ":", "case", "E_V32QImode", ":", "case", "E_V16QImode", ":", "case", "E_V32HImode", ":", "case", "E_V16HImode", ":", "case", "E_V8HImode", ":", "case", "E_V16SImode", ":", "case", "E_V8SImode", ":", "case", "E_V4SImode", ":", "case", "E_V8DImode", ":", "case", "E_V4DImode", ":", "case", "E_V2DImode", ":", "gcc_assert", "(", "vect", ")", ";", "case", "E_V16SFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2SFmode", ":", "case", "E_V8DFmode", ":", "case", "E_V4DFmode", ":", "case", "E_V2DFmode", ":", "n_elt", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "scalar_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "RTVEC_ELT", "(", "v", ",", "0", ")", "=", "value", ";", "for", "(", "i", "=", "1", ";", "i", "<", "n_elt", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "vect", "?", "value", ":", "CONST0_RTX", "(", "scalar_mode", ")", ";", "return", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_build_signbit_mask", ".", "If", "VECT", "is", "true", ",", "then", "replicate", "the", "value", "for", "all", "elements", "of", "the", "vector", "register", "." ]

[ "i386", "0", "1" ]

[]

[ "<s>", "static", "bool", "mem_ok_for_ldrd_strd", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ",", "HOST_WIDE_INT", "*", "align", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "base", "!=", "NULL", "&&", "offset", "!=", "NULL", ")", ";", "if", "(", "side_effects_p", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "SUBREG", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "*", "offset", "=", "const0_rtx", ";", "*", "align", "=", "MEM_ALIGN", "(", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "arm_legitimate_address_p", "(", "DImode", ",", "addr", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "MINUS", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "(", "REG_P", "(", "*", "base", ")", "&&", "CONST_INT_P", "(", "*", "offset", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "for", "gen_operands_ldrd_strd", ".", "Returns", "true", "iff", "the", "memory", "operand", "MEM", "'s", "address", "contains", "an", "immediate", "offset", "from", "the", "base", "register", "and", "has", "no", "side", "effects", ",", "in", "which", "case", "it", "sets", "BASE", "and", "OFFSET", "accordingly", "." ]

[ "arm", "0", "0", "1" ]

[]

[ "<s>", "static", "int", "avr_interrupt_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"interrupt\"", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt", "''", "attribute", "." ]

[ "avr", "\"interrupt\"" ]

[]

[ "<s>", "static", "enum", "flt_eval_method", "ix86_excess_precision", "(", "enum", "excess_precision_type", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "EXCESS_PRECISION_TYPE_FAST", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "case", "EXCESS_PRECISION_TYPE_STANDARD", ":", "case", "EXCESS_PRECISION_TYPE_IMPLICIT", ":", "if", "(", "!", "TARGET_80387", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "else", "if", "(", "!", "TARGET_MIX_SSE_I387", ")", "{", "if", "(", "!", "(", "TARGET_SSE", "&&", "TARGET_SSE_MATH", ")", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE", ";", "else", "if", "(", "TARGET_SSE2", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "}", "return", "(", "type", "==", "EXCESS_PRECISION_TYPE_STANDARD", "?", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ":", "FLT_EVAL_METHOD_UNPREDICTABLE", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "FLT_EVAL_METHOD_UNPREDICTABLE", ";", "}", "</s>" ]

[ "Set", "the", "value", "of", "FLT_EVAL_METHOD", "in", "float.h", ".", "When", "using", "only", "the", "FPU", ",", "assume", "that", "the", "fpcw", "is", "set", "to", "extended", "precision", ";", "when", "using", "only", "SSE", ",", "rounding", "is", "correct", ";", "when", "using", "both", "SSE", "and", "the", "FPU", ",", "the", "rounding", "precision", "is", "indeterminate", ",", "since", "either", "may", "be", "chosen", "apparently", "at", "random", "." ]

[ "i386" ]

[]

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

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

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isStridedAccess", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "llvm", "::", "any_of", "(", "MI", ".", "memoperands", "(", ")", ",", "[", "]", "(", "MachineMemOperand", "*", "MMO", ")", "{", "return", "MMO", "->", "getFlags", "(", ")", "&", "MOStridedAccess", ";", "}", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "load", "or", "store", "is", "a", "strided", "memory", "access", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "process_args", "(", "int", "*", "p_argc", ",", "char", "*", "argv", "[", "]", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "{", "if", "(", "strlen", "(", "argv", "[", "i", "]", ")", "<", "2", ")", "continue", ";", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-I\"", ",", "2", ")", "==", "0", ")", "{", "char", "*", "ptr", ";", "int", "new_len", ",", "search_dirs_len", ";", "ptr", "=", "to_host_dir_spec", "(", "&", "argv", "[", "i", "]", "[", "2", "]", ")", ";", "new_len", "=", "strlen", "(", "ptr", ")", ";", "search_dirs_len", "=", "strlen", "(", "search_dirs", ")", ";", "search_dirs", "=", "xrealloc", "(", "search_dirs", ",", "search_dirs_len", "+", "new_len", "+", "2", ")", ";", "if", "(", "search_dirs_len", ">", "0", ")", "strcat", "(", "search_dirs", ",", "PATH_SEPARATOR_STR", ")", ";", "strcat", "(", "search_dirs", ",", "ptr", ")", ";", "}", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-D\"", ",", "2", ")", "==", "0", ")", "{", "char", "*", "ptr", ";", "int", "new_len", ",", "defines_len", ";", "ptr", "=", "&", "argv", "[", "i", "]", "[", "2", "]", ";", "new_len", "=", "strlen", "(", "ptr", ")", ";", "defines_len", "=", "strlen", "(", "defines", ")", ";", "defines", "=", "xrealloc", "(", "defines", ",", "defines_len", "+", "new_len", "+", "4", ")", ";", "if", "(", "defines_len", ">", "0", ")", "strcat", "(", "defines", ",", "\",\"", ")", ";", "strcat", "(", "defines", ",", "\"\\\"\"", ")", ";", "strcat", "(", "defines", ",", "ptr", ")", ";", "strcat", "(", "defines", ",", "\"\\\"\"", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-v\"", ")", "==", "0", ")", "verbose", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-g0\"", ")", "==", "0", ")", "addarg", "(", "\"/nodebug\"", ")", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-O0\"", ")", "==", "0", ")", "addarg", "(", "\"/noopt\"", ")", ";", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-g\"", ",", "2", ")", "==", "0", ")", "addarg", "(", "\"/debug\"", ")", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-E\"", ")", "==", "0", ")", "addarg", "(", "\"/preprocess\"", ")", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-save-temps\"", ")", "==", "0", ")", "save_temps", "=", "1", ";", "}", "}", "</s>" ]

[ "Preprocess", "the", "number", "of", "args", "ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "for", "the", "VMS", "linker", "." ]

[ "alpha", "1", "2", "\"-I\"", "2", "0", "2", "2", "0", "\"-D\"", "2", "0", "2", "4", "0", "\",\"", "\"\\\"\"", "\"\\\"\"", "\"-v\"", "0", "1", "\"-g0\"", "0", "\"/nodebug\"", "\"-O0\"", "0", "\"/noopt\"", "\"-g\"", "2", "0", "\"/debug\"", "\"-E\"", "0", "\"/preprocess\"", "\"-save-temps\"", "0", "1" ]

[]

[ "<s>", "static", "void", "mips_autovectorize_vector_sizes", "(", "vector_sizes", "*", "sizes", ")", "{", "if", "(", "ISA_HAS_MSA", ")", "sizes", "->", "safe_push", "(", "16", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES", "." ]

[ "mips", "16" ]

[]

[ "<s>", "bool", "tilegx_can_use_return_insn_p", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "cfun", "->", "static_chain_decl", "==", "0", "&&", "compute_total_frame_size", "(", ")", "==", "0", "&&", "tilegx_current_function_is_leaf", "(", ")", "&&", "!", "crtl", "->", "profile", "&&", "!", "df_regs_ever_live_p", "(", "TILEGX_LINK_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "tilegx", "0", "0" ]

[]

[ "<s>", "static", "int", "riscv_immediate_operand_p", "(", "int", "code", ",", "HOST_WIDE_INT", "x", ")", "{", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "return", "true", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "PLUS", ":", "case", "LT", ":", "case", "LTU", ":", "return", "SMALL_OPERAND", "(", "x", ")", ";", "case", "LE", ":", "return", "SMALL_OPERAND", "(", "x", "+", "1", ")", ";", "case", "LEU", ":", "return", "SMALL_OPERAND", "(", "x", "+", "1", ")", "&&", "x", "+", "1", "!=", "0", ";", "case", "GE", ":", "case", "GEU", ":", "return", "x", "==", "1", ";", "default", ":", "return", "x", "==", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "there", "is", "an", "instruction", "that", "implements", "CODE", "and", "accepts", "X", "as", "an", "immediate", "operand", "." ]

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

[]

[ "<s>", "DecodeStatus", "SystemZDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "uint8_t", "Bytes", "[", "6", "]", ";", "Size", "=", "0", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "2", ",", "Bytes", ")", "==", "-", "1", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "uint8_t", "*", "Table", ";", "if", "(", "Bytes", "[", "0", "]", "<", "0x40", ")", "{", "Size", "=", "2", ";", "Table", "=", "DecoderTable16", ";", "}", "else", "if", "(", "Bytes", "[", "0", "]", "<", "0xc0", ")", "{", "Size", "=", "4", ";", "Table", "=", "DecoderTable32", ";", "}", "else", "{", "Size", "=", "6", ";", "Table", "=", "DecoderTable48", ";", "}", "if", "(", "Size", ">", "2", "&&", "Region", ".", "readBytes", "(", "Address", "+", "2", ",", "Size", "-", "2", ",", "Bytes", "+", "2", ")", "==", "-", "1", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint64_t", "Inst", "=", "0", ";", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "<", "Size", ";", "++", "I", ")", "Inst", "=", "(", "Inst", "<<", "8", ")", "|", "Bytes", "[", "I", "]", ";", "return", "decodeInstruction", "(", "Table", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "6", "0", "2", "1", "0", "0x40", "2", "0", "0xc0", "4", "6", "2", "2", "2", "2", "1", "0", "0", "8" ]

[]

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

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

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

[]

[ "<s>", "machine_mode", "rs6000_secondary_memory_needed_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "lra_in_progress", "&&", "mode", "==", "SDmode", ")", "return", "DDmode", ";", "return", "mode", ";", "}", "</s>" ]

[ "Return", "the", "mode", "to", "be", "used", "for", "memory", "when", "a", "secondary", "memory", "location", "is", "needed", ".", "For", "SDmode", "values", "we", "need", "to", "use", "DDmode", ",", "in", "all", "other", "cases", "we", "can", "use", "the", "same", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "riscv_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "rtx", "this_rtx", ",", "temp1", ",", "temp2", ",", "fnaddr", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "fnaddr", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "RISCV_PROLOGUE_TEMP_REGNUM", ")", ";", "temp2", "=", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", "+", "1", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "delta", "!=", "0", ")", "{", "rtx", "offset", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "delta", ")", ")", "{", "riscv_emit_move", "(", "temp1", ",", "offset", ")", ";", "offset", "=", "temp1", ";", "}", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "offset", ")", ")", ";", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "rtx", "addr", ";", "riscv_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "addr", "=", "riscv_add_offset", "(", "temp2", ",", "temp1", ",", "vcall_offset", ")", ";", "riscv_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "temp1", ")", ")", ";", "}", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "fnaddr", ",", "const0_rtx", ",", "NULL", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "split_all_insns_noflow", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", ".", "Generate", "rtl", "rather", "than", "asm", "text", "in", "order", "to", "avoid", "duplicating", "too", "much", "logic", "from", "elsewhere", "." ]

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

[]

[ "<s>", "void", "WebAssemblyExceptionInfo", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "Module", "*", ")", "const", "{", "for", "(", "auto", "*", "WE", ":", "TopLevelExceptions", ")", "WE", "->", "print", "(", "OS", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ThumbRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ")", "return", "ARMBaseRegisterInfo", "::", "getPointerRegClass", "(", "MF", ",", "Kind", ")", ";", "return", "&", "ARM", "::", "tGPRRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "ARM", "ARM", "ARM", "ARM::tGPRRegClass" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "Source", ",", "const", "MachineOperand", "*", "&", "Destination", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ORRWrs", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0x0", ")", "{", "Destination", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Source", "=", "&", "MI", ".", "getOperand", "(", "2", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ORRXrs", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0x0", ")", "{", "Destination", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Source", "=", "&", "MI", ".", "getOperand", "(", "2", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "AArch64", "AArch64", "AArch64::ORRWrs", "1", "AArch64::WZR", "3", "0x0", "0", "2", "AArch64::ORRXrs", "1", "AArch64::XZR", "3", "0x0", "0", "2" ]

[]

[ "<s>", "void", "h8300_swap_out_of_er6", "(", "rtx", "addr", ")", "{", "rtx", "insn", ";", "if", "(", "REGNO", "(", "addr", ")", "!=", "SP_REG", ")", "emit_move_insn", "(", "addr", ",", "hard_frame_pointer_rtx", ")", ";", "insn", "=", "pop", "(", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "else", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", ")", ")", ")", ";", "}", "</s>" ]

[ "Move", "the", "current", "value", "of", "er6", "into", "ADDR", "and", "pop", "its", "old", "value", "from", "the", "stack", "." ]

[ "h8300", "2", "4" ]

[]

[ "<s>", "static", "rtx", "nios2_expand_fpu_builtin", "(", "tree", "exp", ",", "unsigned", "int", "code", ",", "rtx", "target", ")", "{", "struct", "expand_operand", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "enum", "insn_code", "icode", "=", "N2FPU_ICODE", "(", "code", ")", ";", "int", "nargs", ",", "argno", ",", "opno", "=", "0", ";", "int", "num_operands", "=", "N2FPU", "(", "code", ")", ".", "num_operands", ";", "machine_mode", "dst_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "bool", "has_target_p", "=", "(", "dst_mode", "!=", "VOIDmode", ")", ";", "if", "(", "N2FPU_N", "(", "code", ")", "<", "0", ")", "fatal_error", "(", "input_location", ",", "\"cannot call %<__builtin_custom_%s%> without specifying \"", "\"switch %<-mcustom-%s%>\"", ",", "N2FPU_NAME", "(", "code", ")", ",", "N2FPU_NAME", "(", "code", ")", ")", ";", "if", "(", "has_target_p", ")", "create_output_operand", "(", "&", "ops", "[", "opno", "++", "]", ",", "target", ",", "dst_mode", ")", ";", "else", "num_operands", "-=", "1", ";", "nargs", "=", "call_expr_nargs", "(", "exp", ")", ";", "for", "(", "argno", "=", "0", ";", "argno", "<", "nargs", ";", "argno", "++", ")", "{", "tree", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "argno", ")", ";", "create_input_operand", "(", "&", "ops", "[", "opno", "++", "]", ",", "expand_normal", "(", "arg", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg", ")", ")", ")", ";", "}", "if", "(", "!", "maybe_expand_insn", "(", "icode", ",", "num_operands", ",", "ops", ")", ")", "{", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "has_target_p", "?", "gen_reg_rtx", "(", "ops", "[", "0", "]", ".", "mode", ")", ":", "const0_rtx", ";", "}", "return", "has_target_p", "?", "ops", "[", "0", "]", ".", "value", ":", "const0_rtx", ";", "}", "</s>" ]

[ "Helper", "function", "for", "expanding", "FPU", "builtins", "." ]

[ "nios2", "0", "0", "\"cannot call %<__builtin_custom_%s%> without specifying \"", "\"switch %<-mcustom-%s%>\"", "1", "0", "\"invalid argument to built-in function\"", "0", "0" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "FS", "=", "Key", ".", "substr", "(", "CPU", ".", "size", "(", ")", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "512", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "X86" ]

[]

[ "<s>", "static", "bool", "write_as_kernel", "(", "tree", "attrs", ")", "{", "return", "(", "lookup_attribute", "(", "\"kernel\"", ",", "attrs", ")", "!=", "NULL_TREE", "||", "lookup_attribute", "(", "\"omp target entrypoint\"", ",", "attrs", ")", "!=", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Look", "for", "attributes", "in", "ATTRS", "that", "would", "indicate", "we", "must", "write", "a", "function", "as", "a", ".entry", "kernel", "rather", "than", "a", ".func", ".", "Return", "true", "if", "one", "is", "found", "." ]

[ "nvptx", "\"kernel\"", "\"omp target entrypoint\"" ]

[]

[ "<s>", "Optional", "<", "ParamLoadedValue", ">", "AArch64InstrInfo", "::", "describeLoadedValue", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "MOVZWi", ":", "case", "AArch64", "::", "MOVZXi", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "return", "None", ";", "int64_t", "Immediate", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "int", "Shift", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "ParamLoadedValue", "(", "MachineOperand", "::", "CreateImm", "(", "Immediate", "<<", "Shift", ")", ",", "nullptr", ")", ";", "}", "return", "TargetInstrInfo", "::", "describeLoadedValue", "(", "MI", ")", ";", "}", "</s>" ]

[ "Produce", "the", "expression", "describing", "the", "MI", "loading", "a", "value", "into", "the", "physical", "register", "Reg", "." ]

[ "AArch64", "AArch64", "AArch64::MOVZWi", "AArch64::MOVZXi", "1", "1", "2" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "AArch64II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOT", ",", "\"aarch64-got\"", "}", ",", "{", "MO_NC", ",", "\"aarch64-nc\"", "}", ",", "{", "MO_TLS", ",", "\"aarch64-tls\"", "}", ",", "{", "MO_CONSTPOOL", ",", "\"aarch64-constant-pool\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"aarch64-got\"", "\"aarch64-nc\"", "\"aarch64-tls\"", "\"aarch64-constant-pool\"" ]

[]

[ "<s>", "void", "aarch64_parse_one_override_token", "(", "const", "char", "*", "token", ",", "size_t", "length", ",", "struct", "tune_params", "*", "tune", ")", "{", "const", "struct", "aarch64_tuning_override_function", "*", "fn", "=", "aarch64_tuning_override_functions", ";", "const", "char", "*", "option_part", "=", "strchr", "(", "token", ",", "'='", ")", ";", "if", "(", "!", "option_part", ")", "{", "error", "(", "\"tuning string missing in option (%s)\"", ",", "token", ")", ";", "return", ";", "}", "length", "=", "option_part", "-", "token", ";", "option_part", "++", ";", "for", "(", ";", "fn", "->", "name", "!=", "NULL", ";", "fn", "++", ")", "{", "if", "(", "!", "strncmp", "(", "fn", "->", "name", ",", "token", ",", "length", ")", ")", "{", "fn", "->", "parse_override", "(", "option_part", ",", "tune", ")", ";", "return", ";", "}", "}", "error", "(", "\"unknown tuning option (%s)\"", ",", "token", ")", ";", "return", ";", "}", "</s>" ]

[ "Parse", "TOKEN", ",", "which", "has", "length", "LENGTH", "to", "see", "if", "it", "is", "a", "tuning", "option", "we", "understand", ".", "If", "it", "is", ",", "extract", "the", "option", "string", "and", "handoff", "to", "the", "appropriate", "function", "." ]

[ "aarch64", "\"tuning string missing in option (%s)\"", "\"unknown tuning option (%s)\"" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "addPass", "(", "createInsertDivideCheckPass", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "const", "ARMSubtarget", "*", "Subtarget", "=", "&", "getARMSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "hasAnyDataBarrier", "(", ")", "&&", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "HexagonGenInsert", "::", "distance", "(", "const", "MachineBasicBlock", "*", "FromB", ",", "const", "MachineBasicBlock", "*", "ToB", ",", "const", "UnsignedMap", "&", "RPO", ",", "PairMapType", "&", "M", ")", "const", "{", "assert", "(", "FromB", "!=", "ToB", ")", ";", "unsigned", "FromN", "=", "FromB", "->", "getNumber", "(", ")", ",", "ToN", "=", "ToB", "->", "getNumber", "(", ")", ";", "PairMapType", "::", "iterator", "F", "=", "M", ".", "find", "(", "std", "::", "make_pair", "(", "FromN", ",", "ToN", ")", ")", ";", "if", "(", "F", "!=", "M", ".", "end", "(", ")", ")", "return", "F", "->", "second", ";", "unsigned", "ToRPO", "=", "RPO", ".", "lookup", "(", "ToN", ")", ";", "unsigned", "MaxD", "=", "0", ";", "for", "(", "const", "MachineBasicBlock", "*", "PB", ":", "ToB", "->", "predecessors", "(", ")", ")", "{", "if", "(", "PB", "==", "FromB", "||", "RPO", ".", "lookup", "(", "PB", "->", "getNumber", "(", ")", ")", ">=", "ToRPO", ")", "continue", ";", "unsigned", "D", "=", "PB", "->", "size", "(", ")", "+", "distance", "(", "FromB", ",", "PB", ",", "RPO", ",", "M", ")", ";", "if", "(", "D", ">", "MaxD", ")", "MaxD", "=", "D", ";", "}", "M", ".", "insert", "(", "std", "::", "make_pair", "(", "std", "::", "make_pair", "(", "FromN", ",", "ToN", ")", ",", "MaxD", ")", ")", ";", "return", "MaxD", ";", "}", "</s>" ]

[ "Return", "the", "distance", "from", "this", "index", "to", "the", "given", "one", "." ]

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

[]

[ "<s>", "void", "MipsFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MipsRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "RegInfo", "->", "processFunctionBeforeFrameFinalized", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "XCoreDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint16_t", "insn16", ";", "if", "(", "!", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "insn16", ")", ")", "{", "return", "Fail", ";", "}", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "instr", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "uint32_t", "insn32", ";", "if", "(", "!", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "insn32", ")", ")", "{", "return", "Fail", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "instr", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "Fail", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "2", "4" ]

[]

[ "<s>", "static", "bool", "s390_cannot_copy_insn_p", "(", "rtx", "insn", ")", "{", "rtx", "label", "=", "s390_execute_label", "(", "insn", ")", ";", "return", "label", "&&", "label", "!=", "const0_rtx", ";", "}", "</s>" ]

[ "Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "the", "case", "for", "execute", "insns", "that", "carry", "a", "unique", "label", "." ]

[ "s390" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ISD", "::", "SIGN_EXTEND", ")", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "N0", ".", "hasOneUse", "(", ")", "&&", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "{", "auto", "*", "SraAmt", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N0", ".", "getOperand", "(", "1", ")", ")", ";", "SDValue", "Inner", "=", "N0", ".", "getOperand", "(", "0", ")", ";", "if", "(", "SraAmt", "&&", "Inner", ".", "hasOneUse", "(", ")", "&&", "Inner", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "if", "(", "auto", "*", "ShlAmt", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Inner", ".", "getOperand", "(", "1", ")", ")", ")", "{", "unsigned", "Extra", "=", "(", "VT", ".", "getSizeInBits", "(", ")", "-", "N0", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", ")", ";", "unsigned", "NewShlAmt", "=", "ShlAmt", "->", "getZExtValue", "(", ")", "+", "Extra", ";", "unsigned", "NewSraAmt", "=", "SraAmt", "->", "getZExtValue", "(", ")", "+", "Extra", ";", "EVT", "ShiftVT", "=", "N0", ".", "getOperand", "(", "1", ")", ".", "getValueType", "(", ")", ";", "SDValue", "Ext", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "SDLoc", "(", "Inner", ")", ",", "VT", ",", "Inner", ".", "getOperand", "(", "0", ")", ")", ";", "SDValue", "Shl", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "SDLoc", "(", "Inner", ")", ",", "VT", ",", "Ext", ",", "DAG", ".", "getConstant", "(", "NewShlAmt", ",", "ShiftVT", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "SDLoc", "(", "N0", ")", ",", "VT", ",", "Shl", ",", "DAG", ".", "getConstant", "(", "NewSraAmt", ",", "ShiftVT", ")", ")", ";", "}", "}", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::SIGN_EXTEND", "0", "0", "ISD::SRA", "1", "0", "ISD::SHL", "1", "1", "ISD::ANY_EXTEND", "0", "ISD::SHL", "ISD::SRA" ]

[]

[ "<s>", "static", "void", "sh_trampoline_init", "(", "rtx", "tramp_mem", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "tramp", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "tramp_mem", ",", "0", ")", ")", ";", "if", "(", "TARGET_FDPIC", ")", "{", "rtx", "a", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "tramp_mem", ",", "0", ")", ",", "8", ")", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "0", ",", "a", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "4", ",", "sh_get_fdpic_reg_initial_val", "(", ")", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "8", ",", "0xd302", ",", "0xd203", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "12", ",", "0x6122", ",", "0x5c21", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "16", ",", "0x412b", ",", "0x0009", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "20", ",", "cxt", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "24", ",", "fnaddr", ")", ";", "}", "else", "{", "sh_emit_storehi", "(", "tramp_mem", ",", "0", ",", "0xd202", ",", "0xd301", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "4", ",", "0x422b", ",", "0x0009", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "8", ",", "cxt", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "12", ",", "fnaddr", ")", ";", "}", "if", "(", "TARGET_HARD_SH4", ")", "{", "if", "(", "!", "TARGET_INLINE_IC_INVALIDATE", "||", "(", "!", "(", "TARGET_SH4A", "||", "TARGET_SH4_300", ")", "&&", "TARGET_USERMODE", ")", ")", "emit_library_call", "(", "function_symbol", "(", "NULL", ",", "\"__ic_invalidate\"", ",", "FUNCTION_ORDINARY", ")", ".", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "tramp", ",", "SImode", ")", ";", "else", "emit_insn", "(", "gen_ic_invalidate_line", "(", "tramp", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "sh", "0", "0", "0", "8", "0", "4", "8", "0xd302", "0xd203", "12", "0x6122", "0x5c21", "16", "0x412b", "0x0009", "20", "24", "0", "0xd202", "0xd301", "4", "0x422b", "0x0009", "8", "12", "\"__ic_invalidate\"", "1" ]

[]

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

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

[ "Dcpu16", "DCPU16" ]

[]

[ "<s>", "static", "unsigned", "int", "h8300_short_immediate_length", "(", "rtx", "op", ")", "{", "enum", "h8300_operand_class", "opclass", ";", "unsigned", "int", "size", ",", "operand_length", ";", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ";", "operand_length", "=", "h8300_classify_operand", "(", "op", ",", "size", ",", "&", "opclass", ")", ";", "switch", "(", "opclass", ")", "{", "case", "H8OP_REGISTER", ":", "return", "2", ";", "case", "H8OP_MEM_BASE", ":", "case", "H8OP_MEM_ABSOLUTE", ":", "case", "H8OP_MEM_COMPLEX", ":", "return", "4", "+", "operand_length", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Likewise", "short", "immediate", "instructions", "such", "as", "add.w", "#", "xx:3", ",", "OP", "." ]

[ "h8300", "2", "4" ]

[]

[ "<s>", "static", "bool", "cris_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "CRIS_FIRST_ARG_REG", ")", ";", "}", "</s>" ]

[ "Let", "'s", "assume", "all", "functions", "return", "in", "r", "[", "CRIS_FIRST_ARG_REG", "]", "for", "the", "time", "being", "." ]

[ "cris" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Lower br_unless\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Lower br_unless\"" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "LiveRegs", ".", "init", "(", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

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

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

[ "RV16K" ]

[]

[ "<s>", "static", "unsigned", "int", "avr_case_values_threshold", "(", "void", ")", "{", "return", "7", ";", "}", "</s>" ]

[ "Supply", "the", "default", "for", "--", "param", "case-values-threshold=0" ]

[ "avr", "7" ]

[]

[ "<s>", "const", "MCExpr", "*", "ARMElfTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "TM", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "ARM", ")", "return", "TargetLoweringObjectFileELF", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "assert", "(", "Encoding", "==", "DW_EH_PE_absptr", "&&", "\"Can handle absptr encoding only\"", ")", ";", "Triple", "T", "(", "MMI", "->", "getModule", "(", ")", "->", "getTargetTriple", "(", ")", ")", ";", "if", "(", "T", ".", "isOSNaCl", "(", ")", ")", "return", "TargetLoweringObjectFileELF", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "return", "MCSymbolRefExpr", "::", "Create", "(", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ",", "MCSymbolRefExpr", "::", "VK_ARM_TARGET2", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "ARM", "ARM", "ARM", "\"Can handle absptr encoding only\"", "ARM" ]

[]

[ "<s>", "bool", "WebAssemblyStoreResults", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Store Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "MRI", ".", "isSSA", "(", ")", "&&", "\"StoreResults depends on SSA form\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Basic Block: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "unsigned", "ToReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "FromReg", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "for", "(", "auto", "I", "=", "MRI", ".", "use_begin", "(", "FromReg", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "O", "=", "*", "I", "++", ";", "MachineInstr", "*", "Where", "=", "O", ".", "getParent", "(", ")", ";", "if", "(", "Where", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PHI", ")", "{", "MachineBasicBlock", "*", "Pred", "=", "Where", "->", "getOperand", "(", "&", "O", "-", "&", "Where", "->", "getOperand", "(", "0", ")", "+", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MDT", ".", "dominates", "(", "&", "MBB", ",", "Pred", ")", ")", "continue", ";", "}", "else", "{", "if", "(", "&", "MI", "==", "Where", "||", "!", "MDT", ".", "dominates", "(", "&", "MI", ",", "Where", ")", ")", "continue", ";", "}", "Changed", "=", "true", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Setting operand \"", "<<", "O", "<<", "\" in \"", "<<", "*", "Where", "<<", "\" from \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "O", ".", "setReg", "(", "ToReg", ")", ";", "assert", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", "&&", "\"Dead flag set on store result\"", ")", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Store Results **********\\n\"", "\"********** Function: \"", "\"StoreResults depends on SSA form\"", "\"Basic Block: \"", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "0", "3", "0", "1", "\"Setting operand \"", "\" in \"", "\" from \"", "\"\\n\"", "0", "\"Dead flag set on store result\"" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "isAtLeastRelease", "(", "Ord", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlexd", ":", "Intrinsic", "::", "arm_strexd", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int32Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "32", ")", ",", "Int32Ty", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall3", "(", "Strex", ",", "Lo", ",", "Hi", ",", "Addr", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateCall2", "(", "Strex", ",", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Strex", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", ")", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_stlexd", "Intrinsic::arm_strexd", "Intrinsic::getDeclaration", "\"lo\"", "32", "\"hi\"", "Intrinsic::ID", "Intrinsic::arm_stlex", "Intrinsic::arm_strex", "Intrinsic::getDeclaration", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "SystemZMCInstLower", "::", "getExpr", "(", "const", "MachineOperand", "&", "MO", ",", "MCSymbolRefExpr", "::", "VariantKind", "Kind", ")", "const", "{", "const", "MCSymbol", "*", "Symbol", ";", "bool", "HasOffset", "=", "true", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "Symbol", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "HasOffset", "=", "false", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "Symbol", "=", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "Symbol", "=", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "Symbol", "=", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "HasOffset", "=", "false", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "Symbol", "=", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "Symbol", "=", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "Create", "(", "Symbol", ",", "Kind", ",", "Ctx", ")", ";", "if", "(", "HasOffset", ")", "if", "(", "int64_t", "Offset", "=", "MO", ".", "getOffset", "(", ")", ")", "{", "const", "MCExpr", "*", "OffsetExpr", "=", "MCConstantExpr", "::", "Create", "(", "Offset", ",", "Ctx", ")", ";", "Expr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "Expr", ",", "OffsetExpr", ",", "Ctx", ")", ";", "}", "return", "Expr", ";", "}", "</s>" ]

[ "Implementation", "of", "the", "SCEVPredicate", "interface", "." ]

[ "SystemZ", "SystemZ", "\"unknown operand type\"" ]

[]

[ "<s>", "yaml", "::", "MachineFunctionInfo", "*", "GCNTargetMachine", "::", "convertFuncInfoToYAML", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "new", "yaml", "::", "SIMachineFunctionInfo", "(", "*", "MFI", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "MF", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "initialize", "an", "instance", "of", "the", "YAML", "representation", "of", "the", "MachineFunctionInfo", "." ]

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

[]