Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "HexagonInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isCall", "(", ")", ")", "{", "for", "(", "auto", "I", ":", "MBB", "->", "successors", "(", ")", ")", "if", "(", "I", "->", "isEHPad", "(", ")", ")", "return", "true", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "CALLv3nr", ")", "return", "true", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", "->", "isPosition", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "!", "ScheduleInlineAsm", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "Hexagon", "Hexagon", "Hexagon::CALLv3nr" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "Instruction", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "Instruction", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "Instruction", ";", "if", "(", "Instruction", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "Instruction", "->", "getOpcode", "(", ")", "!=", "Lanai", "::", "BT", "&&", "Instruction", "->", "getOpcode", "(", ")", "!=", "Lanai", "::", "BRCC", ")", "{", "break", ";", "}", "Instruction", "->", "eraseFromParent", "(", ")", ";", "Instruction", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"code size not handled\"", "0", "Lanai::BT", "Lanai::BRCC" ]

[]

[ "<s>", "rtx", "mt_function_arg", "(", "const", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ",", "int", "incoming_p", ")", "{", "int", "slotno", ",", "regno", ";", "rtx", "reg", ";", "slotno", "=", "mt_function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "incoming_p", ",", "&", "regno", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "reg", "=", "NULL_RTX", ";", "else", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_ARG", "." ]

[ "mt", "1" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setIfReturnsVoid", "(", "!", "Val", ")", ";", "assert", "(", "!", "Val", "==", "VRegs", ".", "empty", "(", ")", "&&", "\"Return value without a vreg\"", ")", ";", "CallingConv", "::", "ID", "CC", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "bool", "IsShader", "=", "AMDGPU", "::", "isShader", "(", "CC", ")", ";", "const", "bool", "IsWaveEnd", "=", "(", "IsShader", "&&", "MFI", "->", "returnsVoid", "(", ")", ")", "||", "AMDGPU", "::", "isKernel", "(", "CC", ")", ";", "if", "(", "IsWaveEnd", ")", "{", "MIRBuilder", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "auto", "const", "&", "ST", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "ReturnOpc", "=", "IsShader", "?", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ":", "AMDGPU", "::", "S_SETPC_B64_return", ";", "auto", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "ReturnOpc", ")", ";", "Register", "ReturnAddrVReg", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "ReturnAddrVReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "CCR_SGPR_64RegClass", ")", ";", "Ret", ".", "addUse", "(", "ReturnAddrVReg", ")", ";", "}", "if", "(", "!", "lowerReturnVal", "(", "MIRBuilder", ",", "Val", ",", "VRegs", ",", "Ret", ")", ")", "return", "false", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "Register", "LiveInReturn", "=", "MF", ".", "addLiveIn", "(", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "ReturnAddrVReg", ",", "LiveInReturn", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "\"Return value without a vreg\"", "AMDGPU::isShader", "AMDGPU::isKernel", "AMDGPU::S_ENDPGM", "0", "AMDGPU::SI_RETURN_TO_EPILOG", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64_return", "AMDGPU::CCR_SGPR_64RegClass", "AMDGPU::S_SETPC_B64_return", "SI", "AMDGPU::SGPR_64RegClass" ]

[]

[ "<s>", "int", "empty_delay_slot", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "seq", ";", "if", "(", "PREV_INSN", "(", "insn", ")", "==", "NULL", ")", "return", "1", ";", "seq", "=", "NEXT_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "seq", ")", ")", "==", "SEQUENCE", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "a", "branch", "or", "call", "instruction", "will", "be", "emitting", "a", "nop", "into", "its", "delay", "slot", "." ]

[ "sparc", "1", "0", "1" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"M680x0ISelAddressMode \"", "<<", "this", ";", "dbgs", "(", ")", "<<", "\"\\nDisp: \"", "<<", "Disp", ";", "dbgs", "(", ")", "<<", "\", BaseReg: \"", ";", "if", "(", "BaseReg", ".", "getNode", "(", ")", ")", "BaseReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"null\"", ";", "dbgs", "(", ")", "<<", "\", BaseFI: \"", "<<", "BaseFrameIndex", ";", "dbgs", "(", ")", "<<", "\", IndexReg: \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "{", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"null\"", ";", "dbgs", "(", ")", "<<", "\", Scale: \"", "<<", "Scale", ";", "}", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "M680x0", "\"M680x0ISelAddressMode \"", "\"\\nDisp: \"", "\", BaseReg: \"", "\"null\"", "\", BaseFI: \"", "\", IndexReg: \"", "\"null\"", "\", Scale: \"" ]

[]

[ "<s>", "bool", "MCS51TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "int64_t", "Offs", "=", "AM", ".", "BaseOffs", ";", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "isa", "<", "PointerType", ">", "(", "Ty", ")", "&&", "AS", "==", "MCS51", "::", "ProgramMemory", ")", "{", "return", "false", ";", "}", "if", "(", "Offs", "<", "0", ")", "Offs", "=", "-", "Offs", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "isUInt", "<", "6", ">", "(", "Offs", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "0", "0", "MCS51::ProgramMemory", "0", "0", "0", "6" ]

[]

[ "<s>", "static", "hashval_t", "hash", "(", "const", "char", "*", "s", ")", "{", "return", "htab_hash_string", "(", "s", ")", ";", "}", "</s>" ]

[ "Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "." ]

[ "mep" ]

[]

[ "<s>", "const", "BitTracker", "::", "RegisterCell", "&", "lookup", "(", "unsigned", "VR", ")", "{", "unsigned", "RInd", "=", "TargetRegisterInfo", "::", "virtReg2Index", "(", "VR", ")", ";", "if", "(", "RInd", ">=", "CVect", ".", "size", "(", ")", ")", "CVect", ".", "resize", "(", "std", "::", "max", "(", "RInd", "+", "16", ",", "32U", ")", ",", "nullptr", ")", ";", "const", "BitTracker", "::", "RegisterCell", "*", "CP", "=", "CVect", "[", "RInd", "]", ";", "if", "(", "CP", "==", "nullptr", ")", "CP", "=", "CVect", "[", "RInd", "]", "=", "&", "BT", ".", "lookup", "(", "VR", ")", ";", "return", "*", "CP", ";", "}", "</s>" ]

[ "This", "method", "finds", "the", "value", "with", "the", "given", "Name", "in", "the", "the", "symbol", "table", "." ]

[ "Hexagon", "16", "32U" ]

[]

[ "<s>", "int", "memory_address_length", "(", "rtx", "addr", ",", "bool", "lea", ")", "{", "struct", "ix86_address", "parts", ";", "rtx", "base", ",", "index", ",", "disp", ";", "int", "len", ";", "int", "ok", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", "||", "GET_CODE", "(", "addr", ")", "==", "POST_MODIFY", ")", "return", "0", ";", "ok", "=", "ix86_decompose_address", "(", "addr", ",", "&", "parts", ")", ";", "gcc_assert", "(", "ok", ")", ";", "len", "=", "(", "parts", ".", "seg", "==", "SEG_DEFAULT", ")", "?", "0", ":", "1", ";", "if", "(", "TARGET_64BIT", "&&", "!", "lea", "&&", "(", "SImode_address_operand", "(", "addr", ",", "VOIDmode", ")", "||", "(", "parts", ".", "base", "&&", "GET_MODE", "(", "parts", ".", "base", ")", "==", "SImode", ")", "||", "(", "parts", ".", "index", "&&", "GET_MODE", "(", "parts", ".", "index", ")", "==", "SImode", ")", ")", ")", "len", "++", ";", "base", "=", "parts", ".", "base", ";", "index", "=", "parts", ".", "index", ";", "disp", "=", "parts", ".", "disp", ";", "if", "(", "base", "&&", "GET_CODE", "(", "base", ")", "==", "SUBREG", ")", "base", "=", "SUBREG_REG", "(", "base", ")", ";", "if", "(", "index", "&&", "GET_CODE", "(", "index", ")", "==", "SUBREG", ")", "index", "=", "SUBREG_REG", "(", "index", ")", ";", "gcc_assert", "(", "base", "==", "NULL_RTX", "||", "REG_P", "(", "base", ")", ")", ";", "gcc_assert", "(", "index", "==", "NULL_RTX", "||", "REG_P", "(", "index", ")", ")", ";", "if", "(", "base", "&&", "!", "index", "&&", "!", "disp", ")", "{", "if", "(", "base", "==", "arg_pointer_rtx", "||", "base", "==", "frame_pointer_rtx", "||", "REGNO", "(", "base", ")", "==", "SP_REG", "||", "REGNO", "(", "base", ")", "==", "BP_REG", "||", "REGNO", "(", "base", ")", "==", "R12_REG", "||", "REGNO", "(", "base", ")", "==", "R13_REG", ")", "len", "++", ";", "}", "else", "if", "(", "disp", "&&", "!", "base", "&&", "!", "index", ")", "{", "len", "+=", "4", ";", "if", "(", "rip_relative_addr_p", "(", "&", "parts", ")", ")", "len", "++", ";", "}", "else", "{", "if", "(", "disp", ")", "{", "if", "(", "base", "&&", "satisfies_constraint_K", "(", "disp", ")", ")", "len", "+=", "1", ";", "else", "len", "+=", "4", ";", "}", "else", "if", "(", "base", "&&", "(", "REGNO", "(", "base", ")", "==", "BP_REG", "||", "REGNO", "(", "base", ")", "==", "R13_REG", ")", ")", "len", "++", ";", "if", "(", "index", "||", "base", "==", "arg_pointer_rtx", "||", "base", "==", "frame_pointer_rtx", "||", "(", "base", "&&", "(", "REGNO", "(", "base", ")", "==", "SP_REG", "||", "REGNO", "(", "base", ")", "==", "R12_REG", ")", ")", ")", "len", "++", ";", "}", "return", "len", ";", "}", "</s>" ]

[ "Calculate", "the", "length", "of", "the", "memory", "address", "in", "the", "instruction", "encoding", ".", "Does", "not", "include", "the", "one-byte", "modrm", ",", "opcode", ",", "or", "prefix", "." ]

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

[]

[ "<s>", "MCOperand", "PTXAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "{", "MCOperand", "MCOp", ";", "const", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "EncodedReg", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "getReg", "(", ")", ">", "0", ")", "{", "EncodedReg", "=", "MFI", "->", "getEncodedRegister", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "{", "EncodedReg", "=", "0", ";", "}", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "EncodedReg", ")", ";", "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_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "Val", ".", "convertToDouble", "(", ")", ")", ";", "break", ";", "}", "return", "MCOp", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX", "\"Unknown operand type\"", "0", "0" ]

[]

[ "<s>", "static", "void", "init_window", "(", "int", "window_num", ")", "{", "int", "i", ";", "dispatch_windows", "*", "new_list", ";", "if", "(", "window_num", "==", "0", ")", "new_list", "=", "dispatch_window_list", ";", "else", "new_list", "=", "dispatch_window_list1", ";", "new_list", "->", "num_insn", "=", "0", ";", "new_list", "->", "num_uops", "=", "0", ";", "new_list", "->", "window_size", "=", "0", ";", "new_list", "->", "next", "=", "NULL", ";", "new_list", "->", "prev", "=", "NULL", ";", "new_list", "->", "window_num", "=", "window_num", ";", "new_list", "->", "num_imm", "=", "0", ";", "new_list", "->", "num_imm_32", "=", "0", ";", "new_list", "->", "num_imm_64", "=", "0", ";", "new_list", "->", "imm_size", "=", "0", ";", "new_list", "->", "num_loads", "=", "0", ";", "new_list", "->", "num_stores", "=", "0", ";", "new_list", "->", "violation", "=", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "MAX_INSN", ";", "i", "++", ")", "{", "new_list", "->", "window", "[", "i", "]", ".", "insn", "=", "NULL", ";", "new_list", "->", "window", "[", "i", "]", ".", "group", "=", "disp_no_group", ";", "new_list", "->", "window", "[", "i", "]", ".", "path", "=", "no_path", ";", "new_list", "->", "window", "[", "i", "]", ".", "byte_len", "=", "0", ";", "new_list", "->", "window", "[", "i", "]", ".", "imm_bytes", "=", "0", ";", "}", "return", ";", "}", "</s>" ]

[ "This", "function", "initializes", "a", "dispatch", "window", "and", "the", "list", "container", "holding", "a", "pointer", "to", "the", "window", "." ]

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

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Wasn't expecting to be able to lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "LowerSTACKRESTORE", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "lowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "lowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "SDLoc", "(", "Op", ")", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerSRA_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Wasn't expecting to be able to lower this!\"", "ISD::ConstantPool", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SETCC", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "ISD::VASTART", "ISD::VAARG", "ISD::VACOPY", "ISD::STACKRESTORE", "ISD::DYNAMIC_STACKALLOC", "ISD::EH_SJLJ_SETJMP", "ISD::EH_SJLJ_LONGJMP", "ISD::LOAD", "ISD::STORE", "ISD::TRUNCATE", "ISD::SELECT_CC", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "ISD::UINT_TO_FP", "ISD::SINT_TO_FP", "ISD::FLT_ROUNDS_", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SCALAR_TO_VECTOR", "ISD::SIGN_EXTEND_INREG", "ISD::MUL", "ISD::INTRINSIC_W_CHAIN", "ISD::RETURNADDR", "ISD::FRAMEADDR" ]

[]

[ "<s>", "bool", "RISCVMCExpr", "::", "evaluateAsConstant", "(", "int64_t", "&", "Res", ")", "const", "{", "MCValue", "Value", ";", "if", "(", "Kind", "==", "VK_RISCV_PCREL_HI", "||", "Kind", "==", "VK_RISCV_PCREL_LO", "||", "Kind", "==", "VK_RISCV_GOT_HI", "||", "Kind", "==", "VK_RISCV_TPREL_HI", "||", "Kind", "==", "VK_RISCV_TPREL_LO", "||", "Kind", "==", "VK_RISCV_TPREL_ADD", "||", "Kind", "==", "VK_RISCV_TLS_GOT_HI", "||", "Kind", "==", "VK_RISCV_TLS_GD_HI", "||", "Kind", "==", "VK_RISCV_CALL", "||", "Kind", "==", "VK_RISCV_CALL_PLT", ")", "return", "false", ";", "if", "(", "!", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "Value", ",", "nullptr", ",", "nullptr", ")", ")", "return", "false", ";", "if", "(", "!", "Value", ".", "isAbsolute", "(", ")", ")", "return", "false", ";", "Res", "=", "evaluateAsInt64", "(", "Value", ".", "getConstant", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Evaluates", "the", "fixup", "as", "a", "constant", "value", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "HexagonConstEvaluator", "HCE", "(", "MF", ")", ";", "return", "MachineConstPropagator", "(", "HCE", ")", ".", "run", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "MachineBasicBlock", "*", "TeakTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown SELECT_CC!\"", ")", ";", "case", "Teak", "::", "SELECT_CC_Int_ICC", ":", "case", "Teak", "::", "SELECT_CC_Int_ICC_i16", ":", "return", "ExpandSelectCC", "(", "MI", ",", "BB", ",", "Teak", "::", "BRRCond_rel7", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Teak", "Teak", "\"Unknown SELECT_CC!\"", "Teak::SELECT_CC_Int_ICC", "Teak::SELECT_CC_Int_ICC_i16", "Teak::BRRCond_rel7" ]

[]

[ "<s>", "const", "MipsInstrInfo", "*", "MipsInstrInfo", "::", "create", "(", "MipsSubtarget", "&", "STI", ")", "{", "if", "(", "STI", ".", "inMips16Mode", "(", ")", ")", "return", "createMips16InstrInfo", "(", "STI", ")", ";", "return", "createMipsSEInstrInfo", "(", "STI", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "PMLMachineFunctionImport", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SITargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "case", "'s'", ":", "case", "'r'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "32", ":", "case", "16", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ";", "break", ";", "case", "64", ":", "RC", "=", "&", "AMDGPU", "::", "SGPR_64RegClass", ";", "break", ";", "case", "96", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_96RegClass", ";", "break", ";", "case", "128", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_128RegClass", ";", "break", ";", "case", "160", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_160RegClass", ";", "break", ";", "case", "256", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_256RegClass", ";", "break", ";", "case", "512", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_512RegClass", ";", "break", ";", "}", "break", ";", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "32", ":", "case", "16", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "64", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "96", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "case", "128", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_128RegClass", ";", "break", ";", "case", "160", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_160RegClass", ";", "break", ";", "case", "256", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_256RegClass", ";", "break", ";", "case", "512", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_512RegClass", ";", "break", ";", "}", "break", ";", "}", "if", "(", "RC", "&&", "(", "isTypeLegal", "(", "VT", ")", "||", "VT", ".", "SimpleTy", "==", "MVT", "::", "i128", "||", "VT", ".", "SimpleTy", "==", "MVT", "::", "i16", "||", "VT", ".", "SimpleTy", "==", "MVT", "::", "f16", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "RC", ")", ";", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "1", ")", "{", "if", "(", "Constraint", "[", "1", "]", "==", "'v'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'s'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "}", "if", "(", "RC", ")", "{", "uint32_t", "Idx", ";", "bool", "Failed", "=", "Constraint", ".", "substr", "(", "2", ")", ".", "getAsInteger", "(", "10", ",", "Idx", ")", ";", "if", "(", "!", "Failed", "&&", "Idx", "<", "RC", "->", "getNumRegs", "(", ")", ")", "return", "std", "::", "make_pair", "(", "RC", "->", "getRegister", "(", "Idx", ")", ",", "RC", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "0", "0U", "32", "16", "AMDGPU::SReg_32_XM0RegClass", "64", "AMDGPU::SGPR_64RegClass", "96", "AMDGPU::SReg_96RegClass", "128", "AMDGPU::SReg_128RegClass", "160", "AMDGPU::SReg_160RegClass", "256", "AMDGPU::SReg_256RegClass", "512", "AMDGPU::SReg_512RegClass", "0U", "32", "16", "AMDGPU::VGPR_32RegClass", "64", "AMDGPU::VReg_64RegClass", "96", "AMDGPU::VReg_96RegClass", "128", "AMDGPU::VReg_128RegClass", "160", "AMDGPU::VReg_160RegClass", "256", "AMDGPU::VReg_256RegClass", "512", "AMDGPU::VReg_512RegClass", "MVT::i128", "MVT::i16", "MVT::f16", "0U", "1", "1", "AMDGPU::VGPR_32RegClass", "1", "AMDGPU::SGPR_32RegClass", "2", "10" ]

[]

[ "<s>", "BitVector", "SPIRVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Annotate Kernel Features\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Annotate Kernel Features\"" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZTDCPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "Src", ",", "const", "MachineOperand", "*", "&", "Dest", ")", "const", "{", "bool", "isDSPControlWrite", "=", "false", ";", "if", "(", "isReadOrWriteToDSPReg", "(", "MI", ",", "isDSPControlWrite", ")", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "!=", "(", "1", "<<", "4", ")", ")", "return", "false", ";", "else", "if", "(", "isDSPControlWrite", ")", "{", "Src", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Dest", "=", "&", "MI", ".", "getOperand", "(", "2", ")", ";", "}", "else", "{", "Dest", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "&", "MI", ".", "getOperand", "(", "2", ")", ";", "}", "return", "true", ";", "}", "else", "if", "(", "MI", ".", "isMoveReg", "(", ")", "||", "isORCopyInst", "(", "MI", ")", ")", "{", "Dest", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "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", "." ]

[ "Mips", "Mips", "1", "1", "1", "4", "0", "2", "0", "2", "0", "1" ]

[]

[ "<s>", "void", "WebAssemblyTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "int", "mep_register_move_cost", "(", "machine_mode", "mode", ",", "enum", "reg_class", "from", ",", "enum", "reg_class", "to", ")", "{", "if", "(", "mep_have_copro_copro_moves_p", "&&", "reg_class_subset_p", "(", "from", ",", "CR_REGS", ")", "&&", "reg_class_subset_p", "(", "to", ",", "CR_REGS", ")", ")", "{", "if", "(", "TARGET_32BIT_CR_REGS", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "4", ";", "return", "2", ";", "}", "if", "(", "reg_class_subset_p", "(", "from", ",", "CR_REGS", ")", "&&", "reg_class_subset_p", "(", "to", ",", "CR_REGS", ")", ")", "{", "if", "(", "TARGET_32BIT_CR_REGS", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "8", ";", "return", "4", ";", "}", "if", "(", "reg_class_subset_p", "(", "from", ",", "CR_REGS", ")", "||", "reg_class_subset_p", "(", "to", ",", "CR_REGS", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "4", ";", "return", "2", ";", "}", "if", "(", "mep_secondary_memory_needed", "(", "from", ",", "to", ",", "mode", ")", ")", "return", "1000", ";", "if", "(", "MEP_NONGENERAL_CLASS", "(", "from", ")", "&&", "MEP_NONGENERAL_CLASS", "(", "to", ")", ")", "return", "1000", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", ")", "return", "4", ";", "return", "2", ";", "}", "</s>" ]

[ "Implement", "REGISTER_MOVE_COST", ".", "Return", "2", "for", "direct", "single-register", "moves", ",", "4", "for", "direct", "double-register", "moves", ",", "and", "1000", "for", "anything", "that", "requires", "a", "temporary", "register", "or", "temporary", "stack", "slot", "." ]

[ "mep", "4", "2", "8", "4", "4", "2", "1000", "1000", "4", "4", "2" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget21OpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTarget21OpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MIPS_PC21_S2", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTarget21OpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getBranchTarget21OpValue expects only expressions or immediates\"", "0", "Mips::fixup_MIPS_PC21_S2", "0" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMILive", "*", "DAG", "=", "createGenericSchedLive", "(", "C", ")", ";", "DAG", "->", "addMutation", "(", "createLoadClusterDAGMutation", "(", "DAG", "->", "TII", ",", "DAG", "->", "TRI", ")", ")", ";", "DAG", "->", "addMutation", "(", "createStoreClusterDAGMutation", "(", "DAG", "->", "TII", ",", "DAG", "->", "TRI", ")", ")", ";", "DAG", "->", "addMutation", "(", "createAArch64MacroFusionDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "lm32_option_override", "(", "void", ")", "{", "if", "(", "!", "TARGET_BARREL_SHIFT_ENABLED", "&&", "!", "TARGET_SIGN_EXTEND_ENABLED", ")", "target_flags", "|=", "MASK_SIGN_EXTEND_ENABLED", ";", "}", "</s>" ]

[ "Override", "command", "line", "options", "." ]

[ "lm32" ]

[]

[ "<s>", "static", "unsigned", "int", "ix86_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "align", ";", "if", "(", "type", ")", "{", "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "align", "=", "TYPE_ALIGN", "(", "type", ")", ";", "if", "(", "TYPE_EMPTY_P", "(", "type", ")", ")", "return", "PARM_BOUNDARY", ";", "}", "else", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "align", "<", "PARM_BOUNDARY", ")", "align", "=", "PARM_BOUNDARY", ";", "else", "{", "static", "bool", "warned", ";", "unsigned", "int", "saved_align", "=", "align", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "!", "type", ")", "{", "if", "(", "mode", "==", "XFmode", "||", "mode", "==", "XCmode", ")", "align", "=", "PARM_BOUNDARY", ";", "}", "else", "if", "(", "!", "ix86_contains_aligned_value_p", "(", "type", ")", ")", "align", "=", "PARM_BOUNDARY", ";", "if", "(", "align", "<", "128", ")", "align", "=", "PARM_BOUNDARY", ";", "}", "if", "(", "warn_psabi", "&&", "!", "warned", "&&", "align", "!=", "ix86_compat_function_arg_boundary", "(", "mode", ",", "type", ",", "saved_align", ")", ")", "{", "warned", "=", "true", ";", "inform", "(", "input_location", ",", "\"The ABI for passing parameters with %d-byte\"", "\" alignment has changed in GCC 4.6\"", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "}", "return", "align", ";", "}", "</s>" ]

[ "Gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", "." ]

[ "i386", "128", "\"The ABI for passing parameters with %d-byte\"", "\" alignment has changed in GCC 4.6\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM MLA / MLS expansion pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM MLA / MLS expansion pass\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_advance_recurse", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ")", "{", "tree", "f", ";", "for", "(", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "DECL_CHAIN", "(", "f", ")", ")", "if", "(", "TREE_CODE", "(", "f", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "tree", "ftype", "=", "TREE_TYPE", "(", "f", ")", ";", "machine_mode", "mode", ";", "if", "(", "ftype", "==", "error_mark_node", ")", "continue", ";", "mode", "=", "TYPE_MODE", "(", "ftype", ")", ";", "if", "(", "DECL_SIZE", "(", "f", ")", "!=", "0", "&&", "tree_fits_uhwi_p", "(", "bit_position", "(", "f", ")", ")", ")", "bitpos", "+=", "int_bit_position", "(", "f", ")", ";", "if", "(", "TREE_CODE", "(", "ftype", ")", "==", "RECORD_TYPE", ")", "rs6000_darwin64_record_arg_advance_recurse", "(", "cum", ",", "ftype", ",", "bitpos", ")", ";", "else", "if", "(", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ")", ")", "{", "unsigned", "n_fpregs", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", ">>", "3", ";", "rs6000_darwin64_record_arg_advance_flush", "(", "cum", ",", "bitpos", ",", "0", ")", ";", "cum", "->", "fregno", "+=", "n_fpregs", ";", "if", "(", "mode", "==", "SFmode", ")", "{", "if", "(", "cum", "->", "floats_in_gpr", "==", "1", ")", "{", "cum", "->", "words", "++", ";", "cum", "->", "floats_in_gpr", "=", "0", ";", "}", "else", "if", "(", "bitpos", "%", "64", "==", "0", ")", "{", "cum", "->", "floats_in_gpr", "++", ";", "}", "else", "{", "}", "}", "else", "cum", "->", "words", "+=", "n_fpregs", ";", "}", "else", "if", "(", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "1", ")", ")", "{", "rs6000_darwin64_record_arg_advance_flush", "(", "cum", ",", "bitpos", ",", "0", ")", ";", "cum", "->", "vregno", "++", ";", "cum", "->", "words", "+=", "2", ";", "}", "else", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "cum", "->", "intoffset", "=", "bitpos", ";", "}", "}", "</s>" ]

[ "The", "darwin64", "ABI", "calls", "for", "us", "to", "recurse", "down", "through", "structs", ",", "looking", "for", "elements", "passed", "in", "registers", ".", "Unfortunately", ",", "we", "have", "to", "track", "int", "register", "count", "here", "also", "because", "of", "misalignments", "in", "powerpc", "alignment", "mode", "." ]

[ "powerpcspe", "0", "7", "3", "0", "1", "0", "64", "0", "1", "0", "2", "1" ]

[]

[ "<s>", "void", "PIC16TargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "0", ")", ";", "SDValue", "Res", ";", "unsigned", "i", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FORMAL_ARGUMENTS", ":", "Res", "=", "LowerFORMAL_ARGUMENTS", "(", "Op", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "LOAD", ":", "Res", "=", "ExpandLoad", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "CALL", ":", "Res", "=", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "break", ";", "default", ":", "{", "Res", "=", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "}", "N", "=", "Res", ".", "getNode", "(", ")", ";", "unsigned", "NumValues", "=", "N", "->", "getNumValues", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NumValues", ";", "i", "++", ")", "{", "Results", ".", "push_back", "(", "SDValue", "(", "N", ",", "i", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "PIC16", "PIC16", "0", "ISD::FORMAL_ARGUMENTS", "ISD::LOAD", "ISD::CALL", "0" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "SP", "::", "I64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STXri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntPairRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STDri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "FPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "DFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "QFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STQFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::STXri", "0", "SP::IntRegsRegClass", "SP::STri", "0", "SP::IntPairRegClass", "SP::STDri", "0", "SP::FPRegsRegClass", "SP::STFri", "0", "SP::DFPRegsRegClass", "SP::STDFri", "0", "SP::QFPRegsRegClass", "SP::STQFri", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'a'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", "{", "printSymbolOperand", "(", "MO", ",", "O", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", ")", "O", "<<", "\"(%rip)\"", ";", "return", "false", ";", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'('", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "')'", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'c'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", "printSymbolOperand", "(", "MO", ",", "O", ")", ";", "else", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'A'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'*'", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'P'", ":", "print_pcrel_imm", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'n'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "-", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "O", "<<", "'-'", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "1", "0", "0", "\"(%rip)\"", "0" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", "&&", "!", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "continue", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "0", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8mr", ":", "case", "X86", "::", "MOV16mr", ":", "case", "X86", "::", "MOV32mr", ":", "case", "X86", "::", "MOV64mr", ":", "case", "X86", "::", "ST_FpP64m", ":", "case", "X86", "::", "MOVSSmr", ":", "case", "X86", "::", "MOVSDmr", ":", "case", "X86", "::", "MOVAPSmr", ":", "case", "X86", "::", "MOVAPDmr", ":", "case", "X86", "::", "MOVDQAmr", ":", "case", "X86", "::", "MMX_MOVD64mr", ":", "case", "X86", "::", "MMX_MOVQ64mr", ":", "case", "X86", "::", "MMX_MOVNTQmr", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "1", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "X86AddrNumOperands", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::MOV8mr", "X86::MOV16mr", "X86::MOV32mr", "X86::MOV64mr", "X86::ST_FpP64m", "X86::MOVSSmr", "X86::MOVSDmr", "X86::MOVAPSmr", "X86::MOVAPDmr", "X86::MOVDQAmr", "X86::MMX_MOVD64mr", "X86::MMX_MOVQ64mr", "X86::MMX_MOVNTQmr", "0", "1", "2", "3", "1", "1", "2", "0", "3", "0", "0", "X86", "0" ]

[]

[ "<s>", "bool", "X86AvoidSFBPass", "::", "alias", "(", "const", "MachineMemOperand", "&", "Op1", ",", "const", "MachineMemOperand", "&", "Op2", ")", "const", "{", "if", "(", "!", "Op1", ".", "getValue", "(", ")", "||", "!", "Op2", ".", "getValue", "(", ")", ")", "return", "true", ";", "int64_t", "MinOffset", "=", "std", "::", "min", "(", "Op1", ".", "getOffset", "(", ")", ",", "Op2", ".", "getOffset", "(", ")", ")", ";", "int64_t", "Overlapa", "=", "Op1", ".", "getSize", "(", ")", "+", "Op1", ".", "getOffset", "(", ")", "-", "MinOffset", ";", "int64_t", "Overlapb", "=", "Op2", ".", "getSize", "(", ")", "+", "Op2", ".", "getOffset", "(", ")", "-", "MinOffset", ";", "return", "!", "AA", "->", "isNoAlias", "(", "MemoryLocation", "(", "Op1", ".", "getValue", "(", ")", ",", "Overlapa", ",", "Op1", ".", "getAAInfo", "(", ")", ")", ",", "MemoryLocation", "(", "Op2", ".", "getValue", "(", ")", ",", "Overlapb", ",", "Op2", ".", "getAAInfo", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "use_toc_relative_ref", "(", "rtx", "sym", ",", "machine_mode", "mode", ")", "{", "return", "(", "(", "constant_pool_expr_p", "(", "sym", ")", "&&", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "get_pool_constant", "(", "sym", ")", ",", "get_pool_mode", "(", "sym", ")", ")", ")", "||", "(", "TARGET_CMODEL", "==", "CMODEL_MEDIUM", "&&", "SYMBOL_REF_LOCAL_P", "(", "sym", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "POWERPC64_TOC_POINTER_ALIGNMENT", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "the", "given", "SYMBOL_REF", "refers", "to", "a", "constant", "pool", "entry", "that", "we", "have", "put", "in", "the", "TOC", ",", "or", "for", "cmodel=medium", ",", "if", "the", "SYMBOL_REF", "can", "be", "addressed", "relative", "to", "the", "toc", "pointer", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "dump", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "int", "depth", "=", "0", ")", "override", "{", "dumpDepth", "(", "depth", ")", ";", "dbgs", "(", ")", "<<", "\"Region: \"", "<<", "(", "void", "*", ")", "Region", ";", "dbgs", "(", ")", "<<", "\" In: \"", "<<", "printReg", "(", "getBBSelectRegIn", "(", ")", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\", Out: \"", "<<", "printReg", "(", "getBBSelectRegOut", "(", ")", ",", "TRI", ")", "<<", "\"\\n\"", ";", "dumpDepth", "(", "depth", ")", ";", "if", "(", "getSucc", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Succ: \"", "<<", "getSucc", "(", ")", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ";", "else", "dbgs", "(", ")", "<<", "\"Succ: none \\n\"", ";", "for", "(", "auto", "MRTI", ":", "Children", ")", "{", "MRTI", "->", "dump", "(", "TRI", ",", "depth", "+", "1", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "0", "\"Region: \"", "\" In: \"", "\", Out: \"", "\"\\n\"", "\"Succ: \"", "\"\\n\"", "\"Succ: none \\n\"", "1" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "unsigned", "NumDefs", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ";", "assert", "(", "NumDefs", "<=", "1", "&&", "\"Instructions with multiple result values not implemented\"", ")", ";", "OS", "<<", "'\\t'", ";", "if", "(", "NumDefs", "!=", "0", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "OS", "<<", "\"(setlocal @\"", "<<", "TargetRegisterInfo", "::", "virtReg2Index", "(", "Reg", ")", "<<", "' '", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "COPY", ")", "{", "OS", "<<", "'@'", "<<", "TargetRegisterInfo", "::", "virtReg2Index", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "}", "else", "{", "OS", "<<", "'('", "<<", "OpcodeName", "(", "TII", ",", "MI", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "uses", "(", ")", ")", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected machine operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "{", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "OS", "<<", "\" @\"", "<<", "TargetRegisterInfo", "::", "virtReg2Index", "(", "Reg", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "{", "OS", "<<", "' '", "<<", "MO", ".", "getImm", "(", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "OS", "<<", "' '", "<<", "toString", "(", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "OS", "<<", "' '", "<<", "toSymbol", "(", "MO", ".", "getGlobal", "(", ")", "->", "getName", "(", ")", ")", ";", "}", "break", ";", "}", "OS", "<<", "')'", ";", "}", "if", "(", "NumDefs", "!=", "0", ")", "OS", "<<", "')'", ";", "OutStreamer", "->", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "128", "1", "\"Instructions with multiple result values not implemented\"", "0", "0", "\"(setlocal @\"", "WebAssembly::COPY", "1", "\"unexpected machine operand type\"", "\" @\"", "0" ]

[]

[ "<s>", "void", "SystemZHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "const", "MCSchedClassDesc", "*", "SC", "=", "getSchedClass", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ HazardRecognizer emitting \"", ";", "dumpSU", "(", "SU", ",", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "dumpCurrGroup", "(", "\"Decode group before emission\"", ")", ";", ")", ";", "if", "(", "!", "fitsIntoCurrentGroup", "(", "SU", ")", ")", "nextGroup", "(", ")", ";", "DEBUG", "(", "raw_string_ostream", "cgd", "(", "CurGroupDbg", ")", ";", "if", "(", "CurGroupDbg", ".", "length", "(", ")", ")", "cgd", "<<", "\", \"", ";", "dumpSU", "(", "SU", ",", "cgd", ")", ";", ")", ";", "LastEmittedMI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "SU", "->", "isCall", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ Clearing state after call.\\n\"", ";", ")", ";", "Reset", "(", ")", ";", "LastEmittedMI", "=", "SU", "->", "getInstr", "(", ")", ";", "return", ";", "}", "for", "(", "TargetSchedModel", "::", "ProcResIter", "PI", "=", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "PE", "=", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ";", "PI", "!=", "PE", ";", "++", "PI", ")", "{", "if", "(", "SchedModel", "->", "getProcResource", "(", "PI", "->", "ProcResourceIdx", ")", "->", "BufferSize", "==", "1", ")", "continue", ";", "int", "&", "CurrCounter", "=", "ProcResourceCounters", "[", "PI", "->", "ProcResourceIdx", "]", ";", "CurrCounter", "+=", "PI", "->", "Cycles", ";", "if", "(", "(", "CurrCounter", ">", "ProcResCostLim", ")", "&&", "(", "CriticalResourceIdx", "==", "UINT_MAX", "||", "(", "PI", "->", "ProcResourceIdx", "!=", "CriticalResourceIdx", "&&", "CurrCounter", ">", "ProcResourceCounters", "[", "CriticalResourceIdx", "]", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ New critical resource: \"", "<<", "SchedModel", "->", "getProcResource", "(", "PI", "->", "ProcResourceIdx", ")", "->", "Name", "<<", "\"\\n\"", ";", ")", ";", "CriticalResourceIdx", "=", "PI", "->", "ProcResourceIdx", ";", "}", "}", "if", "(", "SU", "->", "isUnbuffered", ")", "{", "LastFPdOpCycleIdx", "=", "getCurrCycleIdx", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ Last FPd cycle index: \"", "<<", "LastFPdOpCycleIdx", "<<", "\"\\n\"", ";", ")", ";", "}", "CurrGroupSize", "+=", "getNumDecoderSlots", "(", "SU", ")", ";", "assert", "(", "CurrGroupSize", "<=", "3", ")", ";", "if", "(", "CurrGroupSize", "==", "3", "||", "SC", "->", "EndGroup", ")", "nextGroup", "(", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "SystemZ", "SystemZ", "\"++ HazardRecognizer emitting \"", "\"\\n\"", "\"Decode group before emission\"", "\", \"", "\"++ Clearing state after call.\\n\"", "1", "\"++ New critical resource: \"", "\"\\n\"", "\"++ Last FPd cycle index: \"", "\"\\n\"", "3", "3" ]

[]

[ "<s>", "void", "FixupLEAPass", "::", "processInstruction", "(", "MachineBasicBlock", "::", "iterator", "&", "I", ",", "MachineFunction", "::", "iterator", "MFI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "int", "AddrOffset", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "AddrOffset", ">=", "0", ")", "{", "AddrOffset", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "MachineOperand", "&", "p", "=", "MI", ".", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "p", ".", "isReg", "(", ")", "&&", "p", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "p", ",", "I", ",", "MFI", ")", ";", "}", "MachineOperand", "&", "q", "=", "MI", ".", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrIndexReg", ")", ";", "if", "(", "q", ".", "isReg", "(", ")", "&&", "q", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "q", ",", "I", ",", "MFI", ")", ";", "}", "}", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

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

[]

[ "<s>", "int", "neon_immediate_valid_for_shift", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "rtx", "*", "modconst", ",", "int", "*", "elementwidth", ",", "bool", "isleftshift", ")", "{", "unsigned", "int", "innersize", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "unsigned", "int", "n_elts", "=", "CONST_VECTOR_NUNITS", "(", "op", ")", ",", "i", ";", "unsigned", "HOST_WIDE_INT", "last_elt", "=", "0", ";", "unsigned", "HOST_WIDE_INT", "maxshift", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "el", "=", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "elpart", ";", "if", "(", "CONST_INT_P", "(", "el", ")", ")", "elpart", "=", "INTVAL", "(", "el", ")", ";", "else", "if", "(", "CONST_DOUBLE_P", "(", "el", ")", ")", "return", "0", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "i", "!=", "0", "&&", "elpart", "!=", "last_elt", ")", "return", "0", ";", "last_elt", "=", "elpart", ";", "}", "maxshift", "=", "innersize", "*", "8", ";", "if", "(", "isleftshift", ")", "{", "if", "(", "last_elt", ">=", "maxshift", ")", "return", "0", ";", "}", "else", "{", "if", "(", "last_elt", "==", "0", "||", "last_elt", ">", "maxshift", ")", "return", "0", ";", "}", "if", "(", "elementwidth", ")", "*", "elementwidth", "=", "innersize", "*", "8", ";", "if", "(", "modconst", ")", "*", "modconst", "=", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "OP", "is", "legal", "for", "use", "in", "a", "VSHR", "or", "VSHL", "instruction", ".", "If", "the", "immediate", "is", "valid", ",", "write", "a", "constant", "suitable", "for", "using", "as", "an", "operand", "to", "VSHR/VSHL", "to", "*", "MODCONST", "and", "the", "corresponding", "element", "width", "to", "*", "ELEMENTWIDTH", ".", "ISLEFTSHIFT", "is", "for", "determine", "left", "or", "right", "shift", ",", "because", "they", "have", "different", "limitations", "." ]

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

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

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

[ "CAHP", "\"Invalid type access!\"" ]

[]

[ "<s>", "static", "void", "output_addr_reloc", "(", "FILE", "*", "stream", ",", "rtx", "x", ",", "HOST_WIDE_INT", "add", ",", "const", "char", "*", "reloc", ")", "{", "if", "(", "*", "reloc", ")", "{", "fputs", "(", "reloc", ",", "stream", ")", ";", "fputc", "(", "'('", ",", "stream", ")", ";", "}", "output_addr_const", "(", "stream", ",", "x", ")", ";", "if", "(", "add", ")", "{", "if", "(", "add", ">", "0", ")", "fputc", "(", "'+'", ",", "stream", ")", ";", "fprintf", "(", "stream", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "add", ")", ";", "}", "if", "(", "*", "reloc", ")", "fputc", "(", "')'", ",", "stream", ")", ";", "}", "</s>" ]

[ "Print", "reloc", "(", "x", "+", "add", ")", "." ]

[ "or1k", "0" ]

[]

[ "<s>", "void", "PPCIncomingValueHandler", "::", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "{", "markPhysRegUsed", "(", "PhysReg", ")", ";", "IncomingValueHandler", "::", "assignValueToReg", "(", "ValVReg", ",", "PhysReg", ",", "VA", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "PIC16AsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "printLibcallDecls", "(", ")", ";", "DbgInfo", ".", "EmitVarDebugInfo", "(", "M", ")", ";", "O", "<<", "\"\\n\\t\"", "<<", "\".EOF\"", ";", "O", "<<", "\"\\n\\t\"", "<<", "\"END\\n\"", ";", "bool", "Result", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "\"\\n\\t\"", "\".EOF\"", "\"\\n\\t\"", "\"END\\n\"" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasD32", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "unsigned", "Reg", ":", "RC", ")", "for", "(", "MCSubRegIterator", "SI", "(", "Reg", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "0", "16", "ARM::D16", "ARM::GPRPairRegClass" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "PatmosSinglePathInfo", "&", "PSPI", "=", "getAnalysis", "<", "PatmosSinglePathInfo", ">", "(", ")", ";", "bool", "changed", "=", "false", ";", "if", "(", "PSPI", ".", "isConverting", "(", "MF", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Preparing \"", "<<", "MF", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "doPrepareFunction", "(", "MF", ")", ";", "changed", "|=", "true", ";", "}", "return", "changed", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "\"[Single-Path] Preparing \"", "\"\\n\"" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "StoreOpcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "isBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "return", "Dis", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "isBranch", ",", "Offset", ",", "Width", ")", ";", "}", "</s>" ]

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

[ "Sparc" ]

[]

[ "<s>", "bool", "TVMRematerialize", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Cheap Definition Rematerializing **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "TVMFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "TVMFunctionInfo", ">", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "*", "TRI", "=", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "AliasAnalysis", "&", "AA", "=", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "LiveIntervals", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MII", "=", "MBB", ".", "begin", "(", ")", ",", "MIE", "=", "MBB", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", "++", "MII", ")", "{", "auto", "&", "MI", "=", "*", "MII", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "continue", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", ")", "continue", ";", "for", "(", "MachineOperand", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isUse", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "Def", "=", "GetVRegDef", "(", "Reg", ",", "&", "MI", ",", "MRI", ",", "LIS", ")", ";", "if", "(", "!", "Def", ")", "continue", ";", "if", "(", "Def", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "continue", ";", "if", "(", "TVM", "::", "isArgument", "(", "*", "Def", ")", ")", "continue", ";", "if", "(", "ShouldRematerialize", "(", "*", "Def", ",", "AA", ",", "TII", ")", ")", "{", "RematerializeCheapDef", "(", "Reg", ",", "Op", ",", "*", "Def", ",", "MBB", ",", "MI", ".", "getIterator", "(", ")", ",", "LIS", ",", "MFI", ",", "MRI", ",", "TII", ",", "TRI", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "\"********** Cheap Definition Rematerializing **********\\n\"", "\"********** Function: \"", "TVM", "TVM", "TVM", "TVM", "TVM::isArgument" ]

[]

[ "<s>", "const", "CallLowering", "*", "AMDGPUSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getCallLowering", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "AMDGPU", "AMDGPU", "\"Access to GlobalISel APIs not set\"" ]

[]

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

[ "atIssueLimit", "-", "Return", "true", "if", "no", "more", "instructions", "may", "be", "issued", "in", "this", "cycle", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "SDValue", "AArch64SelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "const", "AArch64Subtarget", "&", "STI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "char", "*", "bzeroEntry", "=", "(", "V", "&&", "V", "->", "isNullValue", "(", ")", ")", "?", "STI", ".", "getBZeroEntry", "(", ")", ":", "nullptr", ";", "if", "(", "bzeroEntry", "&&", "(", "!", "SizeValue", "||", "SizeValue", "->", "getZExtValue", "(", ")", ">", "256", ")", ")", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "STI", ".", "getTargetLowering", "(", ")", ";", "EVT", "IntPtr", "=", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "Type", "*", "IntPtrTy", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "CallingConv", "::", "C", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "bzeroEntry", ",", "IntPtr", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "256", "AArch64", "0" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "uint64_t", "TSFlags", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "(", "getForcedEncodingSize", "(", ")", "==", "32", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "getForcedEncodingSize", "(", ")", "==", "64", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "isForcedDPP", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "DPP", ")", ")", "||", "(", "isForcedSDWA", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", ")", ")", "return", "Match_InvalidOperand", ";", "if", "(", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOPAsmPrefer32Bit", ")", "&&", "getForcedEncodingSize", "(", ")", "!=", "64", ")", "return", "Match_PreferE32", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_sdwa_vi", "||", "Inst", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_sdwa_vi", ")", "{", "auto", "OpNum", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Inst", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst_sel", ")", ";", "const", "auto", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "Op", ".", "isImm", "(", ")", "||", "Op", ".", "getImm", "(", ")", "!=", "AMDGPU", "::", "SDWA", "::", "SdwaSel", "::", "DWORD", ")", "{", "return", "Match_InvalidOperand", ";", "}", "}", "if", "(", "(", "TSFlags", "&", "SIInstrFlags", "::", "FLAT", ")", "&&", "!", "hasFlatOffsets", "(", ")", ")", "{", "auto", "OpNum", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Inst", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "const", "auto", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "Op", ".", "getImm", "(", ")", "!=", "0", ")", "return", "Match_InvalidOperand", ";", "}", "return", "Match_Success", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "32", "SIInstrFlags::VOP3", "64", "SIInstrFlags::VOP3", "SIInstrFlags::DPP", "SIInstrFlags::SDWA", "SIInstrFlags::VOP3", "SIInstrFlags::VOPAsmPrefer32Bit", "64", "AMDGPU::V_MAC_F32_sdwa_vi", "AMDGPU::V_MAC_F16_sdwa_vi", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::SDWA", "SIInstrFlags::FLAT", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0" ]

[]

[ "<s>", "void", "tilegx_emit_conditional_branch", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "cmp_rtx", "=", "tilegx_emit_cc_test", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "cmp_mode", ",", "false", ")", ";", "rtx", "branch_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ",", "pc_rtx", ")", ")", ";", "emit_jump_insn", "(", "branch_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "comparison", "for", "a", "conditional", "branch", "." ]

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

[]

[ "<s>", "void", "SICInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "ADDR", "=", "SIC", "::", "ADD", ";", "unsigned", "SUBR", "=", "SIC", "::", "SUB", ";", "unsigned", "LDi", "=", "SIC", "::", "LDi", ";", "unsigned", "LDi4", "=", "SIC", "::", "LDi4", ";", "unsigned", "LDiL", "=", "SIC", "::", "LDiL", ";", "unsigned", "T", "=", "SIC", "::", "T", ";", "if", "(", "isUInt", "<", "20", ">", "(", "Amount", ")", ")", "{", "if", "(", "isUInt", "<", "12", ">", "(", "Amount", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "LDi", ")", ",", "T", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "LDi4", ")", ",", "T", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDR", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "T", ")", ";", "}", "else", "if", "(", "isUInt", "<", "20", ">", "(", "-", "Amount", ")", ")", "{", "if", "(", "isUInt", "<", "12", ">", "(", "-", "Amount", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "LDi", ")", ",", "T", ")", ".", "addImm", "(", "-", "Amount", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "LDi4", ")", ",", "T", ")", ".", "addImm", "(", "-", "Amount", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SUBR", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "T", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "LDiL", ")", ",", "T", ")", ".", "addImm", "(", "Amount", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDR", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "T", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "SIC", "SIC", "SIC::ADD", "SIC::SUB", "SIC::LDi", "SIC::LDi4", "SIC::LDiL", "SIC::T", "20", "12", "20", "12" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86AsmBackend", "::", "allowAutoPadding", "(", ")", "const", "{", "return", "(", "AlignBoundary", "!=", "Align", "(", "1", ")", "&&", "AlignBranchType", "!=", "X86", "::", "AlignBranchNone", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "target", "might", "automatically", "pad", "instructions", "and", "thus", "need", "to", "emit", "padding", "enable/disable", "directives", "around", "sensative", "code", "." ]

[ "X86", "X86", "1", "X86::AlignBranchNone" ]

[]

[ "<s>", "static", "tree", "s390_expand_overloaded_builtin", "(", "location_t", "loc", ",", "unsigned", "fcode", ",", "vec", "<", "tree", ",", "va_gc", ">", "*", "arglist", ",", "tree", "return_type", ")", "{", "switch", "(", "fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_step", ":", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ")", "!=", "VECTOR_TYPE", ")", "{", "error_at", "(", "loc", ",", "\"builtin vec_step can only be used on vector types.\"", ")", ";", "return", "error_mark_node", ";", "}", "return", "build_int_cst", "(", "NULL_TREE", ",", "TYPE_VECTOR_SUBPARTS", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ")", ")", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xl", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xld2", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xlw4", ":", "return", "build2", "(", "MEM_REF", ",", "return_type", ",", "fold_build_pointer_plus", "(", "(", "*", "arglist", ")", "[", "1", "]", ",", "(", "*", "arglist", ")", "[", "0", "]", ")", ",", "build_int_cst", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "1", "]", ")", ",", "0", ")", ")", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xst", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xstd2", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xstw4", ":", "return", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ",", "build1", "(", "INDIRECT_REF", ",", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ",", "fold_build_pointer_plus", "(", "(", "*", "arglist", ")", "[", "2", "]", ",", "(", "*", "arglist", ")", "[", "1", "]", ")", ")", ",", "(", "*", "arglist", ")", "[", "0", "]", ")", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_load_pair", ":", "return", "build_constructor_va", "(", "return_type", ",", "2", ",", "NULL_TREE", ",", "(", "*", "arglist", ")", "[", "0", "]", ",", "NULL_TREE", ",", "(", "*", "arglist", ")", "[", "1", "]", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Expand", "builtins", "which", "can", "directly", "be", "mapped", "to", "tree", "expressions", ".", "LOC", "-", "location", "information", "FCODE", "-", "function", "code", "of", "the", "builtin", "ARGLIST", "-", "value", "supposed", "to", "be", "passed", "as", "arguments", "RETURN-TYPE", "-", "expected", "return", "type", "of", "the", "builtin" ]

[ "s390", "0", "\"builtin vec_step can only be used on vector types.\"", "0", "1", "0", "1", "0", "0", "0", "2", "1", "0", "2", "0", "1" ]

[]

[ "<s>", "static", "rtx", "arm_expand_neon_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", ">=", "ARM_BUILTIN_NEON_BASE", "&&", "!", "TARGET_NEON", ")", "{", "fatal_error", "(", "input_location", ",", "\"You must enable NEON instructions\"", "\" (e.g. %<-mfloat-abi=softfp%> %<-mfpu=neon%>)\"", "\" to use these intrinsics.\"", ")", ";", "return", "const0_rtx", ";", "}", "if", "(", "fcode", "==", "ARM_BUILTIN_NEON_LANE_CHECK", ")", "{", "tree", "nlanes", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "nlanes", ")", "==", "INTEGER_CST", ")", ";", "rtx", "lane_idx", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "lane_idx", ")", ")", "neon_lane_bounds", "(", "lane_idx", ",", "0", ",", "TREE_INT_CST_LOW", "(", "nlanes", ")", ",", "exp", ")", ";", "else", "error", "(", "\"%Klane index must be a constant immediate\"", ",", "exp", ")", ";", "return", "const0_rtx", ";", "}", "arm_builtin_datum", "*", "d", "=", "&", "neon_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_NEON_PATTERN_START", "]", ";", "return", "arm_expand_builtin_1", "(", "fcode", ",", "exp", ",", "target", ",", "d", ")", ";", "}", "</s>" ]

[ "Expand", "a", "Neon", "builtin", ",", "i.e", ".", "those", "registered", "only", "if", "TARGET_NEON", "holds", ".", "Most", "of", "these", "are", "``", "special", "''", "because", "they", "do", "n't", "have", "symbolic", "constants", "defined", "per-instruction", "or", "per", "instruction-variant", ".", "Instead", ",", "the", "required", "info", "is", "looked", "up", "in", "the", "table", "neon_builtin_data", "." ]

[ "arm", "\"You must enable NEON instructions\"", "\" (e.g. %<-mfloat-abi=softfp%> %<-mfpu=neon%>)\"", "\" to use these intrinsics.\"", "0", "1", "0", "\"%Klane index must be a constant immediate\"" ]

[]

[ "<s>", "static", "unsigned", "int", "arm_elf_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "target_pure_code", ")", "flags", "|=", "SECTION_ARM_PURECODE", ";", "return", "flags", ";", "}", "</s>" ]

[ "Implements", "the", "TARGET_SECTION_FLAGS", "hook", ".", "If", "DECL", "is", "a", "function", "declaration", "and", "pure-code", "is", "passed", "as", "an", "option", "then", "add", "the", "SFH_ARM_PURECODE", "attribute", "to", "the", "section", "flags", ".", "NAME", "is", "the", "section", "'s", "name", "and", "RELOC", "indicates", "whether", "the", "declarations", "initializer", "may", "contain", "runtime", "relocations", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "mips_return_in_msb", "(", "const_tree", "valtype", ")", "{", "if", "(", "!", "TARGET_NEWABI", "||", "!", "TARGET_BIG_ENDIAN", "||", "!", "AGGREGATE_TYPE_P", "(", "valtype", ")", ")", "return", "false", ";", "tree", "fields", "[", "2", "]", ";", "bool", "has_cxx_zero_width_bf", "=", "false", ";", "bool", "has_cxx17_empty_base", "=", "false", ";", "return", "(", "mips_fpr_return_fields", "(", "valtype", ",", "fields", ",", "&", "has_cxx_zero_width_bf", ",", "&", "has_cxx17_empty_base", ")", "==", "0", "||", "has_cxx_zero_width_bf", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MSB", ".", "For", "n32", "&", "n64", ",", "we", "should", "return", "a", "value", "in", "the", "most", "significant", "part", "of", "$", "2/", "$", "3", "if", ":", "-", "the", "target", "is", "big-endian", ";", "-", "the", "value", "has", "a", "structure", "or", "union", "type", "(", "we", "generalize", "this", "to", "cover", "aggregates", "from", "other", "languages", "too", ")", ";", "and", "-", "the", "structure", "is", "not", "returned", "in", "floating-point", "registers", "." ]

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

[]

[ "<s>", "static", "void", "mips_avoid_hazard", "(", "rtx_insn", "*", "after", ",", "rtx_insn", "*", "insn", ",", "int", "*", "hilo_delay", ",", "rtx", "*", "delayed_reg", ",", "rtx", "lo_reg", ",", "bool", "*", "fs_delay", ")", "{", "rtx", "pattern", ",", "set", ";", "int", "nops", ",", "ninsns", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "pattern", ")", ">=", "0", ")", "cfun", "->", "machine", "->", "all_noreorder_p", "=", "false", ";", "ninsns", "=", "get_attr_length", "(", "insn", ")", "/", "4", ";", "if", "(", "ninsns", "==", "0", ")", "return", ";", "if", "(", "*", "hilo_delay", "<", "2", "&&", "reg_set_p", "(", "lo_reg", ",", "pattern", ")", ")", "nops", "=", "2", "-", "*", "hilo_delay", ";", "else", "if", "(", "*", "delayed_reg", "!=", "0", "&&", "reg_referenced_p", "(", "*", "delayed_reg", ",", "pattern", ")", ")", "nops", "=", "1", ";", "else", "if", "(", "*", "fs_delay", "&&", "get_attr_can_delay", "(", "insn", ")", "==", "CAN_DELAY_NO", "&&", "GET_CODE", "(", "PATTERN", "(", "after", ")", ")", "!=", "SEQUENCE", "&&", "GET_CODE", "(", "pattern", ")", "!=", "ASM_INPUT", "&&", "asm_noperands", "(", "pattern", ")", "<", "0", ")", "nops", "=", "1", ";", "else", "nops", "=", "0", ";", "*", "hilo_delay", "+=", "nops", ";", "while", "(", "nops", "--", ">", "0", ")", "emit_insn_after", "(", "gen_hazard_nop", "(", ")", ",", "after", ")", ";", "*", "hilo_delay", "+=", "ninsns", ";", "*", "delayed_reg", "=", "0", ";", "*", "fs_delay", "=", "false", ";", "if", "(", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "break", ";", "case", "HAZARD_FORBIDDEN_SLOT", ":", "if", "(", "TARGET_CB_MAYBE", ")", "*", "fs_delay", "=", "true", ";", "break", ";", "case", "HAZARD_HILO", ":", "*", "hilo_delay", "=", "0", ";", "break", ";", "case", "HAZARD_DELAY", ":", "set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "set", ")", ";", "*", "delayed_reg", "=", "SET_DEST", "(", "set", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Subroutine", "of", "mips_reorg", ".", "If", "there", "is", "a", "hazard", "between", "INSN", "and", "a", "previous", "instruction", ",", "avoid", "it", "by", "inserting", "nops", "after", "instruction", "AFTER", ".", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "describe", "the", "hazards", "that", "apply", "at", "this", "point", ".", "If", "*", "DELAYED_REG", "is", "non-null", ",", "INSN", "must", "wait", "a", "cycle", "before", "using", "the", "value", "of", "that", "register", ".", "*", "HILO_DELAY", "counts", "the", "number", "of", "instructions", "since", "the", "last", "hilo", "hazard", "(", "that", "is", ",", "the", "number", "of", "instructions", "since", "the", "last", "mflo", "or", "mfhi", ")", ".", "After", "inserting", "nops", "for", "INSN", ",", "update", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "for", "the", "next", "instruction", ".", "LO_REG", "is", "an", "rtx", "for", "the", "LO", "register", ",", "used", "in", "dependence", "checking", "." ]

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

[]

[ "<s>", "static", "int", "get_max_pos", "(", "state_t", "state", ")", "{", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "pos_6", ")", ")", "return", "6", ";", "else", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "pos_5", ")", ")", "return", "5", ";", "else", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "pos_4", ")", ")", "return", "4", ";", "else", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "pos_3", ")", ")", "return", "3", ";", "else", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "pos_2", ")", ")", "return", "2", ";", "else", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "pos_1", ")", ")", "return", "1", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "The", "following", "function", "returns", "position", "in", "the", "two", "window", "bundle", "for", "given", "STATE", "." ]

[ "ia64", "6", "5", "4", "3", "2", "1", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "X86TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "X86PassConfig", "(", "this", ",", "PM", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isPredicated", "(", "unsigned", "Opcode", ")", "const", "{", "const", "uint64_t", "F", "=", "get", "(", "Opcode", ")", ".", "TSFlags", ";", "return", "(", "F", ">>", "HexagonII", "::", "PredicatedPos", ")", "&", "HexagonII", "::", "PredicatedMask", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "Hexagon", "Hexagon", "HexagonII::PredicatedPos", "HexagonII::PredicatedMask" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", "=", "0", ")", "const", "override", "{", "return", "&", "Patmos", "::", "RRegsRegClass", ";", "}", "</s>" ]

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

[ "Patmos", "0", "Patmos::RRegsRegClass" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "PatmosCallGraphBuilder", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "PatmosStackCacheAnalysisInfo", ">", "(", ")", ";", "ModulePass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "def_builtin", "(", "const", "char", "*", "name", ",", "enum", "bpf_builtins", "code", ",", "tree", "type", ")", "{", "tree", "t", "=", "add_builtin_function", "(", "name", ",", "type", ",", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "bpf_builtins", "[", "code", "]", "=", "t", ";", "return", "t", ";", "}", "</s>" ]

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

[ "bpf" ]

[]

[ "<s>", "static", "bool", "ix86_expand_vector_init_one_var", "(", "bool", "mmx_ok", ",", "machine_mode", "mode", ",", "rtx", "target", ",", "rtx", "vals", ",", "int", "one_var", ")", "{", "rtx", "var", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", ")", ";", "machine_mode", "wmode", ";", "rtx", "const_vec", ",", "x", ";", "const_vec", "=", "copy_rtx", "(", "vals", ")", ";", "XVECEXP", "(", "const_vec", ",", "0", ",", "one_var", ")", "=", "CONST0_RTX", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "const_vec", ",", "0", ")", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "case", "E_V2SFmode", ":", "case", "E_V2SImode", ":", "return", "false", ";", "case", "E_V4DImode", ":", "if", "(", "!", "TARGET_64BIT", ")", "return", "false", ";", "case", "E_V8HFmode", ":", "case", "E_V16HFmode", ":", "case", "E_V4DFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V16HImode", ":", "case", "E_V32QImode", ":", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "case", "E_V8HImode", ":", "case", "E_V4HImode", ":", "break", ";", "case", "E_V16QImode", ":", "if", "(", "TARGET_SSE4_1", ")", "break", ";", "wmode", "=", "V8HImode", ";", "goto", "widen", ";", "case", "E_V8QImode", ":", "if", "(", "TARGET_MMX_WITH_SSE", "&&", "TARGET_SSE4_1", ")", "break", ";", "wmode", "=", "V4HImode", ";", "goto", "widen", ";", "case", "E_V4QImode", ":", "if", "(", "TARGET_SSE4_1", ")", "break", ";", "wmode", "=", "V2HImode", ";", "widen", ":", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", "^", "1", ")", ";", "if", "(", "one_var", "&", "1", ")", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "var", "=", "expand_simple_binop", "(", "HImode", ",", "ASHIFT", ",", "var", ",", "GEN_INT", "(", "8", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "GEN_INT", "(", "INTVAL", "(", "x", ")", "&", "0xff", ")", ";", "}", "else", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "x", "=", "gen_int_mode", "(", "UINTVAL", "(", "x", ")", "<<", "8", ",", "HImode", ")", ";", "}", "if", "(", "x", "!=", "const0_rtx", ")", "var", "=", "expand_simple_binop", "(", "HImode", ",", "IOR", ",", "var", ",", "x", ",", "var", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "emit_move_insn", "(", "x", ",", "gen_lowpart", "(", "wmode", ",", "const_vec", ")", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "x", ",", "var", ",", "one_var", ">>", "1", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "x", ")", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "emit_move_insn", "(", "target", ",", "const_vec", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "target", ",", "var", ",", "one_var", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vector_init", ".", "Store", "into", "TARGET", "a", "vector", "consisting", "of", "the", "values", "in", "VALS", ".", "It", "is", "known", "that", "all", "elements", "except", "ONE_VAR", "are", "constants", ".", "Return", "true", "if", "successful", "." ]

[ "i386", "0", "0", "0", "0", "1", "1", "8", "1", "0xff", "8", "1", "1" ]

[]

[ "<s>", "void", "sparc_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "const", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "const", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "const", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "i", ",", "n_var", "=", "0", ";", "bool", "all_same", ";", "rtx", "mem", ";", "all_same", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "x", ")", ")", "n_var", "++", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ";", "return", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "4", ")", "{", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "target", ")", ",", "gen_lowpart", "(", "SImode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "8", ")", "{", "emit_move_insn", "(", "gen_lowpart", "(", "DImode", ",", "target", ")", ",", "gen_lowpart", "(", "DImode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "GET_MODE_SIZE", "(", "word_mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "2", "*", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "{", "emit_move_insn", "(", "gen_highpart", "(", "word_mode", ",", "target", ")", ",", "gen_lowpart", "(", "word_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "word_mode", ",", "target", ")", ",", "gen_lowpart", "(", "word_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ")", ";", "return", ";", "}", "if", "(", "all_same", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "{", "if", "(", "TARGET_VIS2", ")", "{", "vector_init_bshuffle", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "mode", ",", "inner_mode", ")", ";", "return", ";", "}", "if", "(", "mode", "==", "V8QImode", ")", "{", "vector_init_fpmerge", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "mode", "==", "V4HImode", ")", "{", "vector_init_faligndata", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "return", ";", "}", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "i", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ")", ";", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "initialize", "TARGET", "to", "values", "for", "individual", "fields", "VALS", "." ]

[ "sparc", "0", "0", "0", "0", "0", "0", "0", "0", "4", "0", "0", "8", "0", "0", "2", "0", "0", "0", "1", "8", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "ia64_expand_load_address", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", ";", "if", "(", "GET_MODE", "(", "dest", ")", "!=", "Pmode", ")", "dest", "=", "gen_rtx_REG_offset", "(", "dest", ",", "Pmode", ",", "REGNO", "(", "dest", ")", ",", "byte_lowpart_offset", "(", "Pmode", ",", "GET_MODE", "(", "dest", ")", ")", ")", ";", "if", "(", "TARGET_NO_PIC", ")", "return", "false", ";", "if", "(", "small_addr_symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "TARGET_AUTO_PIC", ")", "emit_insn", "(", "gen_load_gprel64", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "src", ")", ")", "emit_insn", "(", "gen_load_fptr", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "sdata_symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "emit_insn", "(", "gen_load_gprel", "(", "dest", ",", "src", ")", ")", ";", "else", "{", "HOST_WIDE_INT", "addend", "=", "0", ";", "rtx", "tmp", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST", ")", "{", "HOST_WIDE_INT", "hi", ",", "lo", ";", "hi", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ")", ";", "lo", "=", "(", "(", "hi", "&", "0x3fff", ")", "^", "0x2000", ")", "-", "0x2000", ";", "hi", "=", "hi", "-", "lo", ";", "if", "(", "lo", "!=", "0", ")", "{", "addend", "=", "lo", ";", "src", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ",", "hi", ")", ";", "}", "}", "tmp", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "src", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "pic_offset_table_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "gen_const_mem", "(", "Pmode", ",", "dest", ")", ",", "src", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "tmp", ")", ")", ";", "if", "(", "addend", ")", "{", "tmp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "GEN_INT", "(", "addend", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "tmp", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "symbolic", "constant", "load", "." ]

[ "ia64", "0", "0", "1", "0x3fff", "0x2000", "0x2000", "0", "0", "0" ]

[]

[ "<s>", "void", "XtensaDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "llvm", "::", "dbgs", "(", ")", "<<", "\"Attempting to do a select\\n\"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Attempting to do a select\\n\"", "\"== \"" ]

[]

[ "<s>", "void", "M680x0PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createM680x0CollapseMOVEMPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "BPFPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createBPFMIPreEmitCheckingPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "if", "(", "!", "DisableMIPeephole", ")", "addPass", "(", "createBPFMIPreEmitPeepholePass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "avr_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "const", "char", "*", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "unsigned", "int", "id", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "avr_builtin_description", "*", "d", "=", "&", "avr_bdesc", "[", "id", "]", ";", "tree", "arg0", ";", "rtx", "op0", ";", "gcc_assert", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", ";", "switch", "(", "id", ")", "{", "case", "AVR_BUILTIN_NOP", ":", "emit_insn", "(", "gen_nopv", "(", "GEN_INT", "(", "1", ")", ")", ")", ";", "return", "0", ";", "case", "AVR_BUILTIN_DELAY_CYCLES", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_delay_cycles", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_NOPS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_nops", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_INSERT_BITS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "{", "error", "(", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", ",", "bname", ")", ";", "return", "target", ";", "}", "break", ";", "}", "case", "AVR_BUILTIN_ROUNDHR", ":", "case", "AVR_BUILTIN_ROUNDUHR", ":", "case", "AVR_BUILTIN_ROUNDR", ":", "case", "AVR_BUILTIN_ROUNDUR", ":", "case", "AVR_BUILTIN_ROUNDLR", ":", "case", "AVR_BUILTIN_ROUNDULR", ":", "case", "AVR_BUILTIN_ROUNDLLR", ":", "case", "AVR_BUILTIN_ROUNDULLR", ":", "case", "AVR_BUILTIN_ROUNDHK", ":", "case", "AVR_BUILTIN_ROUNDUHK", ":", "case", "AVR_BUILTIN_ROUNDK", ":", "case", "AVR_BUILTIN_ROUNDUK", ":", "case", "AVR_BUILTIN_ROUNDLK", ":", "case", "AVR_BUILTIN_ROUNDULK", ":", "case", "AVR_BUILTIN_ROUNDLLK", ":", "case", "AVR_BUILTIN_ROUNDULLK", ":", "if", "(", "TREE_CODE", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", "!=", "INTEGER_CST", ")", "break", ";", "int", "rbit", "=", "(", "int", ")", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "rbit", ">=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ")", "{", "warning", "(", "OPT_Wextra", ",", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", ",", "rbit", ",", "GET_MODE_FBIT", "(", "mode", ")", ")", ";", "return", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "if", "(", "rbit", "<=", "-", "(", "int", ")", "GET_MODE_IBIT", "(", "mode", ")", ")", "{", "warning", "(", "0", ",", "\"rounding result will always be 0\"", ")", ";", "return", "CONST0_RTX", "(", "mode", ")", ";", "}", "break", ";", "}", "if", "(", "d", "->", "icode", "==", "CODE_FOR_nothing", "&&", "DECL_ASSEMBLER_NAME", "(", "get_callee_fndecl", "(", "exp", ")", ")", "!=", "NULL_TREE", ")", "{", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "gcc_assert", "(", "d", "->", "icode", "!=", "CODE_FOR_nothing", ")", ";", "gcc_assert", "(", "d", "->", "n_args", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "d", "->", "n_args", "==", "0", ")", "{", "emit_insn", "(", "(", "GEN_FCN", "(", "d", "->", "icode", ")", ")", "(", "target", ")", ")", ";", "return", "NULL_RTX", ";", "}", "return", "avr_default_expand_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "}", "</s>" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "avr", "0", "1", "0", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", "1", "1", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", "0", "0", "\"rounding result will always be 0\"", "0" ]

[]

[ "<s>", "static", "machine_mode", "s390_cc_modes_compatible", "(", "machine_mode", "m1", ",", "machine_mode", "m2", ")", "{", "if", "(", "m1", "==", "m2", ")", "return", "m1", ";", "switch", "(", "m1", ")", "{", "case", "CCZmode", ":", "if", "(", "m2", "==", "CCUmode", "||", "m2", "==", "CCTmode", "||", "m2", "==", "CCZ1mode", "||", "m2", "==", "CCSmode", "||", "m2", "==", "CCSRmode", "||", "m2", "==", "CCURmode", ")", "return", "m2", ";", "return", "VOIDmode", ";", "case", "CCSmode", ":", "case", "CCUmode", ":", "case", "CCTmode", ":", "case", "CCSRmode", ":", "case", "CCURmode", ":", "case", "CCZ1mode", ":", "if", "(", "m2", "==", "CCZmode", ")", "return", "m1", ";", "return", "VOIDmode", ";", "default", ":", "return", "VOIDmode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "If", "two", "condition", "code", "modes", "are", "compatible", ",", "return", "a", "condition", "code", "mode", "which", "is", "compatible", "with", "both", ".", "Otherwise", ",", "return", "VOIDmode", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction_fini", "(", "gcall", "*", "call", ",", "offload_attrs", "*", "oa", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "enum", "tree_code", "op", "=", "(", "enum", "tree_code", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "4", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "tree", "r", "=", "NULL_TREE", ";", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_VECTOR", "&&", "oa", "->", "vector_length", "==", "PTX_WARP_SIZE", ")", "{", "for", "(", "int", "shfl", "=", "PTX_WARP_SIZE", "/", "2", ";", "shfl", ">", "0", ";", "shfl", "=", "shfl", ">>", "1", ")", "{", "tree", "other_var", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "var", ")", ")", ";", "nvptx_generate_vector_shuffle", "(", "gimple_location", "(", "call", ")", ",", "other_var", ",", "var", ",", "shfl", ",", "&", "seq", ")", ";", "r", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "var", ")", ")", ";", "gimplify_assign", "(", "r", ",", "fold_build2", "(", "op", ",", "TREE_TYPE", "(", "var", ")", ",", "var", ",", "other_var", ")", ",", "&", "seq", ")", ";", "var", "=", "r", ";", "}", "}", "else", "{", "tree", "accum", "=", "NULL_TREE", ";", "if", "(", "level", "==", "GOMP_DIM_WORKER", "||", "level", "==", "GOMP_DIM_VECTOR", ")", "{", "tree", "offset", "=", "gimple_call_arg", "(", "call", ",", "5", ")", ";", "tree", "call", "=", "nvptx_get_shared_red_addr", "(", "TREE_TYPE", "(", "var", ")", ",", "offset", ",", "level", "==", "GOMP_DIM_VECTOR", ")", ";", "tree", "ptr", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "call", ")", ")", ";", "gimplify_assign", "(", "ptr", ",", "call", ",", "&", "seq", ")", ";", "accum", "=", "ptr", ";", "}", "else", "if", "(", "integer_zerop", "(", "ref_to_res", ")", ")", "r", "=", "var", ";", "else", "accum", "=", "ref_to_res", ";", "if", "(", "accum", ")", "{", "gsi_insert_seq_before", "(", "&", "gsi", ",", "seq", ",", "GSI_SAME_STMT", ")", ";", "seq", "=", "NULL", ";", "r", "=", "nvptx_reduction_update", "(", "gimple_location", "(", "call", ")", ",", "&", "gsi", ",", "accum", ",", "var", ",", "op", ",", "level", ")", ";", "}", "}", "if", "(", "lhs", ")", "gimplify_assign", "(", "lhs", ",", "r", ",", "&", "seq", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "NVPTX", "implementation", "of", "GOACC_REDUCTION_FINI", "." ]

[ "nvptx", "1", "2", "3", "4", "2", "0", "1", "5" ]

[]

[ "<s>", "static", "enum", "mips_shadow_set", "mips_use_shadow_register_set", "(", "tree", "type", ")", "{", "tree", "attr", "=", "lookup_attribute", "(", "\"use_shadow_register_set\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "tree", "args", ";", "if", "(", "attr", "==", "NULL", ")", "return", "SHADOW_SET_NO", ";", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "return", "SHADOW_SET_YES", ";", "return", "SHADOW_SET_INTSTACK", ";", "}", "</s>" ]

[ "Return", "the", "mips_shadow_set", "if", "the", "``", "use_shadow_register_set", "''", "attribute", "is", "set", "for", "a", "function", "." ]

[ "mips", "\"use_shadow_register_set\"" ]

[]

[ "<s>", "bool", "GCNDPPCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasDPP", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Must be run on SSA\"", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "E", "=", "MBB", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "auto", "&", "MI", "=", "*", "I", "++", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MOV_B32_dpp", "&&", "combineDPPMov", "(", "MI", ")", ")", "{", "Changed", "=", "true", ";", "++", "NumDPPMovsCombined", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"Must be run on SSA\"", "AMDGPU::V_MOV_B32_dpp" ]

[]

[ "<s>", "static", "void", "cr16_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "l", "=", "GET_MODE_BITSIZE", "(", "arg", ".", "mode", ")", "/", "BITS_PER_WORD", ";", "if", "(", "!", "cum", "->", "last_parm_in_reg", ")", "return", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", "||", "(", "cum", "->", "ints", "<", "0", ")", ")", "return", ";", "if", "(", "(", "arg", ".", "mode", "==", "SImode", ")", "||", "(", "arg", ".", "mode", "==", "HImode", ")", "||", "(", "arg", ".", "mode", "==", "QImode", ")", "||", "(", "arg", ".", "mode", "==", "DImode", ")", ")", "{", "if", "(", "l", "<=", "1", ")", "cum", "->", "ints", "+=", "1", ";", "else", "cum", "->", "ints", "+=", "l", ";", "}", "else", "if", "(", "(", "arg", ".", "mode", "==", "SFmode", ")", "||", "(", "arg", ".", "mode", "==", "DFmode", ")", ")", "cum", "->", "ints", "+=", "l", ";", "else", "if", "(", "arg", ".", "mode", "==", "BLKmode", ")", "{", "if", "(", "(", "l", "=", "enough_regs_for_param", "(", "cum", ",", "arg", ".", "type", ",", "arg", ".", "mode", ")", ")", "!=", "0", ")", "cum", "->", "ints", "+=", "l", ";", "}", "return", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "FUNCTION_ARG_ADVANCE", "defined", "in", "cr16.h", "." ]

[ "cr16", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIWholeQuadModeID", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIPreAllocateWWMRegsID", ")", ";", "if", "(", "OptExecMaskPreRA", ")", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIOptimizeExecMaskingPreRAID", ")", ";", "if", "(", "isPassEnabled", "(", "EnablePreRAOptimizations", ")", ")", "insertPass", "(", "&", "RenameIndependentSubregsID", ",", "&", "GCNPreRAOptimizationsID", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "Less", ")", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFormMemoryClausesID", ")", ";", "if", "(", "OptVGPRLiveRange", ")", "insertPass", "(", "&", "LiveVariablesID", ",", "&", "SIOptimizeVGPRLiveRangeID", ",", "false", ")", ";", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "if", "(", "EnableDCEInRA", ")", "insertPass", "(", "&", "DetectDeadLanesID", ",", "&", "DeadMachineInstructionElimID", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

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

[]

[ "<s>", "void", "addEdge", "(", "SCANode", "*", "src", ",", "SCANode", "*", "dst", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "index", ")", "{", "E", ".", "push_back", "(", "new", "SCAEdge", "(", "src", "->", "yId", ",", "dst", "->", "yId", ",", "MBB", "->", "getName", "(", ")", ",", "index", ",", "MBB", "->", "getNumber", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "DAG", "edge", "to", "the", "given", "SU", "with", "the", "given", "predecessor", "dependence", "data", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "paired_emit_vector_compare", "(", "enum", "rtx_code", "rcode", ",", "rtx", "dest", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "rtx", "tmp1", ",", "max", ",", "min", ";", "gcc_assert", "(", "TARGET_PAIRED_FLOAT", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "op0", ")", "==", "GET_MODE", "(", "op1", ")", ")", ";", "switch", "(", "rcode", ")", "{", "case", "LT", ":", "case", "LTU", ":", "paired_emit_vector_compare", "(", "GE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "GE", ":", "case", "GEU", ":", "emit_insn", "(", "gen_subv2sf3", "(", "tmp", ",", "cc_op0", ",", "cc_op1", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "dest", ",", "tmp", ",", "op0", ",", "op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "return", ";", "case", "LE", ":", "case", "LEU", ":", "paired_emit_vector_compare", "(", "GE", ",", "dest", ",", "op0", ",", "op1", ",", "cc_op1", ",", "cc_op0", ")", ";", "return", ";", "case", "GT", ":", "paired_emit_vector_compare", "(", "LE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "EQ", ":", "tmp1", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "max", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "min", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "emit_insn", "(", "gen_subv2sf3", "(", "tmp", ",", "cc_op0", ",", "cc_op1", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "max", ",", "tmp", ",", "cc_op0", ",", "cc_op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "emit_insn", "(", "gen_subv2sf3", "(", "tmp", ",", "cc_op1", ",", "cc_op0", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "min", ",", "tmp", ",", "cc_op0", ",", "cc_op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "emit_insn", "(", "gen_subv2sf3", "(", "tmp1", ",", "min", ",", "max", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "dest", ",", "tmp1", ",", "op0", ",", "op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "return", ";", "case", "NE", ":", "paired_emit_vector_compare", "(", "EQ", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNLE", ":", "paired_emit_vector_compare", "(", "LE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNLT", ":", "paired_emit_vector_compare", "(", "LT", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNGE", ":", "paired_emit_vector_compare", "(", "GE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNGT", ":", "paired_emit_vector_compare", "(", "GT", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Emit", "vector", "compare", "for", "code", "RCODE", ".", "DEST", "is", "destination", ",", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ",", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", ".", "This", "is", "a", "recursive", "function", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "unsigned", "XCoreRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "XCore", "::", "R10", ":", "XCore", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "XCore", "XCore", "XCore::R10", "XCore::SP" ]

[]

[ "<s>", "static", "rtx", "gen_rx_rtsd_vector", "(", "unsigned", "int", "adjust", ",", "unsigned", "int", "low", ",", "unsigned", "int", "high", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "bias", "=", "3", ";", "unsigned", "int", "count", "=", "(", "high", "-", "low", ")", "+", "bias", ";", "rtx", "vector", ";", "vector", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "adjust", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", "-", "2", ";", "i", "++", ")", "XVECEXP", "(", "vector", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "low", "+", "i", ")", ",", "gen_rtx_MEM", "(", "SImode", ",", "i", "==", "0", "?", "stack_pointer_rtx", ":", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "i", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "count", "-", "1", ")", "=", "ret_rtx", ";", "return", "vector", ";", "}", "</s>" ]

[ "Generate", "a", "PARALLEL", "which", "will", "satisfy", "the", "rx_rtsd_vector", "predicate", "." ]

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

[]

[ "<s>", "bool", "PPCAIXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "MAI", "->", "usesDwarfFileAndLocDirectives", "(", ")", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ")", "OutStreamer", "->", "doFinalizationAtSectionEnd", "(", "OutStreamer", "->", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getTextSection", "(", ")", ")", ";", "for", "(", "MCSymbol", "*", "Sym", ":", "ExtSymSDNodeSymbols", ")", "OutStreamer", "->", "emitSymbolAttribute", "(", "Sym", ",", "MCSA_Extern", ")", ";", "return", "PPCAsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "MipsAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "return", "StringSwitch", "<", "Optional", "<", "MCFixupKind", ">>", "(", "Name", ")", ".", "Case", "(", "\"R_MIPS_NONE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_NONE", ")", ".", "Case", "(", "\"R_MIPS_32\"", ",", "FK_Data_4", ")", ".", "Default", "(", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "Mips", "Mips", "\"R_MIPS_NONE\"", "Mips::fixup_Mips_NONE", "\"R_MIPS_32\"" ]

[]

[ "<s>", "static", "rtx", "frv_legitimize_argument", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "arg", ")", "{", "enum", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "mode", ";", "if", "(", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "arg", ",", "mode", ")", ")", "return", "arg", ";", "else", "return", "copy_to_mode_reg", "(", "mode", ",", "arg", ")", ";", "}", "</s>" ]

[ "Given", "that", "ARG", "is", "being", "passed", "as", "operand", "OPNUM", "to", "instruction", "ICODE", ",", "check", "whether", "ARG", "satisfies", "the", "operand", "'s", "constraints", ".", "If", "it", "does", "n't", ",", "copy", "ARG", "to", "a", "temporary", "register", "and", "return", "that", ".", "Otherwise", "return", "ARG", "itself", "." ]

[ "frv" ]

[]

[ "<s>", "unsigned", "X86AsmBackend", "::", "getMaximumNopSize", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "STI", ".", "hasFeature", "(", "X86", "::", "Is16Bit", ")", ")", "return", "4", ";", "if", "(", "!", "STI", ".", "hasFeature", "(", "X86", "::", "FeatureNOPL", ")", "&&", "!", "STI", ".", "hasFeature", "(", "X86", "::", "Is64Bit", ")", ")", "return", "1", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast7ByteNOP", "]", ")", "return", "7", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast15ByteNOP", "]", ")", "return", "15", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast11ByteNOP", "]", ")", "return", "11", ";", "return", "10", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "size", "of", "a", "nop", "in", "bytes", "on", "this", "target", "." ]

[ "X86", "X86", "X86::Is16Bit", "4", "X86::FeatureNOPL", "X86::Is64Bit", "1", "X86::TuningFast7ByteNOP", "7", "X86::TuningFast15ByteNOP", "15", "X86::TuningFast11ByteNOP", "11", "10" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "AArch64" ]

[]

[ "<s>", "int", "get_ta", "(", "rtx", "ta", ")", "{", "if", "(", "INTVAL", "(", "ta", ")", "==", "TAIL_ANY", ")", "return", "INVALID_ATTRIBUTE", ";", "return", "INTVAL", "(", "ta", ")", ";", "}", "</s>" ]

[ "Get", "ta", "according", "to", "operand", "[", "tail_op_idx", "]", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "static", "int", "last_insn_address", "=", "0", ";", "const", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "TARGET_ADDRESSES", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"; 0x%x %d\\n\"", ",", "INSN_ADDRESSES", "(", "uid", ")", ",", "INSN_ADDRESSES", "(", "uid", ")", "-", "last_insn_address", ")", ";", "last_insn_address", "=", "INSN_ADDRESSES", "(", "uid", ")", ";", "}", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "h8300", "0", "\"; 0x%x %d\\n\"" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_xcoff_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "size_t", "len", ";", "if", "(", "*", "name", "==", "'*'", ")", "name", "++", ";", "len", "=", "strlen", "(", "name", ")", ";", "if", "(", "name", "[", "len", "-", "1", "]", "==", "']'", ")", "return", "ggc_alloc_string", "(", "name", ",", "len", "-", "4", ")", ";", "else", "return", "name", ";", "}", "</s>" ]

[ "Remove", "any", "trailing", "[", "DS", "]", "or", "the", "like", "from", "the", "symbol", "name", "." ]

[ "rs6000", "1", "4" ]

[]