Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "riscv_epilogue_uses", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", "return", "true", ";", "if", "(", "epilogue_completed", "&&", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "regno", "]", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "EPILOGUE_USES", "." ]

[ "riscv" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "AMDGPUTargetLowering", "::", "splitVector", "(", "const", "SDValue", "&", "N", ",", "const", "SDLoc", "&", "DL", ",", "const", "EVT", "&", "LoVT", ",", "const", "EVT", "&", "HiVT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "LoVT", ".", "getVectorNumElements", "(", ")", "+", "(", "HiVT", ".", "isVector", "(", ")", "?", "HiVT", ".", "getVectorNumElements", "(", ")", ":", "1", ")", "<=", "N", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", "&&", "\"More vector elements requested than available!\"", ")", ";", "auto", "IdxTy", "=", "getVectorIdxTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "LoVT", ",", "N", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "IdxTy", ")", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "HiVT", ".", "isVector", "(", ")", "?", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "HiVT", ",", "N", ",", "DAG", ".", "getConstant", "(", "LoVT", ".", "getVectorNumElements", "(", ")", ",", "DL", ",", "IdxTy", ")", ")", ";", "return", "std", "::", "make_pair", "(", "Lo", ",", "Hi", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "value", "into", "two", "parts", "of", "types", "LoVT", "and", "HiVT", "." ]

[ "AMDGPU", "AMDGPU", "1", "\"More vector elements requested than available!\"", "ISD::EXTRACT_SUBVECTOR", "0", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "DCPU16TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "DCPU16", "::", "GR16RegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Dcpu16", "DCPU16", "1", "0", "0U", "DCPU16::GR16RegClass" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "unsigned", "Opcode", "=", "Orig", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MI", "->", "substituteRegister", "(", "Orig", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "break", ";", "}", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CPI", "=", "Orig", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "Orig", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "CPI", ")", ".", "addImm", "(", "PCLabelId", ")", ";", "MIB", "->", "setMemRefs", "(", "Orig", "->", "memoperands_begin", "(", ")", ",", "Orig", "->", "memoperands_end", "(", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "ARM", "ARM", "0", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1" ]

[]

[ "<s>", "static", "void", "som_output_text_section_asm_op", "(", "const", "char", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "TARGET_SOM", ")", ";", "if", "(", "TARGET_GAS", ")", "{", "if", "(", "cfun", "&&", "cfun", "->", "machine", "&&", "!", "cfun", "->", "machine", "->", "in_nsubspa", ")", "{", "cfun", "->", "machine", "->", "in_nsubspa", "=", "1", ";", "if", "(", "cfun", "->", "decl", "&&", "DECL_ONE_ONLY", "(", "cfun", "->", "decl", ")", "&&", "!", "DECL_WEAK", "(", "cfun", "->", "decl", ")", ")", "{", "output_section_asm_op", "(", "\"\\t.SPACE $TEXT$\\n\"", "\"\\t.NSUBSPA $CODE$,QUAD=0,ALIGN=8,\"", "\"ACCESS=44,SORT=24,COMDAT\"", ")", ";", "return", ";", "}", "}", "else", "{", "gcc_assert", "(", "!", "cfun", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "in_nsubspa", "==", "2", ")", ";", "in_section", "=", "NULL", ";", "}", "output_section_asm_op", "(", "\"\\t.SPACE $TEXT$\\n\\t.NSUBSPA $CODE$\"", ")", ";", "return", ";", "}", "output_section_asm_op", "(", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $CODE$\"", ")", ";", "}", "</s>" ]

[ "A", "get_unnamed_section", "callback", "for", "switching", "to", "the", "text", "section", ".", "This", "function", "is", "only", "used", "with", "SOM", ".", "Because", "we", "do", "n't", "support", "named", "subspaces", ",", "we", "can", "only", "create", "a", "new", "subspace", "or", "switch", "back", "to", "the", "default", "text", "subspace", "." ]

[ "pa", "1", "\"\\t.SPACE $TEXT$\\n\"", "\"\\t.NSUBSPA $CODE$,QUAD=0,ALIGN=8,\"", "\"ACCESS=44,SORT=24,COMDAT\"", "2", "\"\\t.SPACE $TEXT$\\n\\t.NSUBSPA $CODE$\"", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $CODE$\"" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"MSP430ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "nullptr", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "MSP430", "\"MSP430ISelAddressMode \"", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "virtual", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "PowerPC", "0" ]

[]

[ "<s>", "bool", "get_ta", "(", ")", "const", "{", "return", "m_ta", ";", "}", "</s>" ]

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

[ "riscv" ]

[]

[ "<s>", "SDValue", "BlackfinTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "12", ",", "4", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Blackfin", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "TargetRegisterClass", "*", "RC", "=", "VA", ".", "getLocReg", "(", ")", "==", "BF", "::", "P0", "?", "BF", "::", "PRegisterClass", ":", "BF", "::", "DRegisterClass", ";", "assert", "(", "RC", "->", "contains", "(", "VA", ".", "getLocReg", "(", ")", ")", "&&", "\"Unexpected regclass in CCState\"", ")", ";", "assert", "(", "RC", "->", "hasType", "(", "RegVT", ")", "&&", "\"Unexpected regclass in CCState\"", ")", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "Reg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "\"CCValAssign must be RegLoc or MemLoc\"", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "NULL", ",", "0", ",", "false", ",", "false", ",", "0", ")", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Blackfin", "ISD::InputArg", "16", "12", "4", "0", "BF::P0", "BF::PRegisterClass", "BF::DRegisterClass", "\"Unexpected regclass in CCState\"", "\"Unexpected regclass in CCState\"", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"CCValAssign must be RegLoc or MemLoc\"", "MVT::i32", "0", "0" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "getFramePointerSaveOffset", "(", ")", "const", "{", "return", "FramePointerSaveOffset", ";", "}", "</s>" ]

[ "getFramePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "frame", "pointer", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "bool", "s390_call_saved_register_used", "(", "tree", "argument_list", ")", "{", "CUMULATIVE_ARGS", "cum", ";", "tree", "parameter", ";", "enum", "machine_mode", "mode", ";", "tree", "type", ";", "rtx", "parm_rtx", ";", "int", "reg", ";", "INIT_CUMULATIVE_ARGS", "(", "cum", ",", "NULL", ",", "NULL", ",", "0", ",", "0", ")", ";", "while", "(", "argument_list", ")", "{", "parameter", "=", "TREE_VALUE", "(", "argument_list", ")", ";", "argument_list", "=", "TREE_CHAIN", "(", "argument_list", ")", ";", "gcc_assert", "(", "parameter", ")", ";", "if", "(", "TREE_CODE", "(", "parameter", ")", "==", "ERROR_MARK", ")", "return", "true", ";", "type", "=", "TREE_TYPE", "(", "parameter", ")", ";", "gcc_assert", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "gcc_assert", "(", "mode", ")", ";", "if", "(", "pass_by_reference", "(", "&", "cum", ",", "mode", ",", "type", ",", "true", ")", ")", "{", "mode", "=", "Pmode", ";", "type", "=", "build_pointer_type", "(", "type", ")", ";", "}", "parm_rtx", "=", "s390_function_arg", "(", "&", "cum", ",", "mode", ",", "type", ",", "0", ")", ";", "s390_function_arg_advance", "(", "&", "cum", ",", "mode", ",", "type", ",", "0", ")", ";", "if", "(", "parm_rtx", "&&", "REG_P", "(", "parm_rtx", ")", ")", "{", "for", "(", "reg", "=", "0", ";", "reg", "<", "HARD_REGNO_NREGS", "(", "REGNO", "(", "parm_rtx", ")", ",", "GET_MODE", "(", "parm_rtx", ")", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_regs", "[", "reg", "+", "REGNO", "(", "parm_rtx", ")", "]", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "given", "ARGUMENT_LIST", "would", "use", "a", "caller", "saved", "register", ".", "This", "is", "used", "to", "decide", "whether", "sibling", "call", "optimization", "could", "be", "performed", "on", "the", "respective", "function", "call", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "(", "CONST_DOUBLE_P", "(", "x", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", ")", "return", "true", ";", "if", "(", "!", "GET_MODE_SIZE", "(", "mode", ")", ".", "is_constant", "(", ")", ")", "return", "aarch64_simd_valid_immediate", "(", "x", ",", "NULL", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "return", "!", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "x", ")", ";", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "==", "(", "VEC_ADVSIMD", "|", "VEC_STRUCT", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "poly_int64", "offset", ";", "if", "(", "poly_int_rtx_p", "(", "x", ",", "&", "offset", ")", ")", "return", "aarch64_offset_temporaries", "(", "false", ",", "offset", ")", "<=", "1", ";", "x", "=", "strip_offset_and_salt", "(", "x", ",", "&", "offset", ")", ";", "if", "(", "!", "offset", ".", "is_constant", "(", ")", "&&", "aarch64_offset_temporaries", "(", "true", ",", "offset", ")", ">", "0", ")", "return", "false", ";", "if", "(", "maybe_ne", "(", "offset", ",", "0", ")", "&&", "SYMBOL_REF_P", "(", "x", ")", "&&", "SYMBOL_REF_ANCHOR_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "&&", "!", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "true", ";", "if", "(", "LABEL_REF_P", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "hook", ".", "Return", "true", "for", "constants", "that", "should", "be", "rematerialized", "rather", "than", "spilled", "." ]

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

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "||", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getTargetData", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "rs6000_init_machine_status", "(", "void", ")", "{", "stack_info", ".", "reload_completed", "=", "0", ";", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Functions", "to", "init", ",", "mark", "and", "free", "struct", "machine_function", ".", "These", "will", "be", "called", ",", "via", "pointer", "variables", ",", "from", "push_function_context", "and", "pop_function_context", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isABI_O32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVector", "<", "MBBInfo", ",", "16", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "computeOffset", "(", "I", "->", "Br", ")", "/", "4", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "16", "16", "4", "4", "0" ]

[]

[ "<s>", "int", "arm_coproc_mem_operand_wb", "(", "rtx", "op", ",", "int", "wb_level", ")", "{", "gcc_assert", "(", "wb_level", "==", "0", "||", "wb_level", "==", "1", "||", "wb_level", "==", "2", ")", ";", "rtx", "ind", ";", "if", "(", "!", "(", "reload_in_progress", "||", "reload_completed", "||", "lra_in_progress", ")", "&&", "(", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "arg_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_incoming_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_outgoing_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_dynamic_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_vars_rtx", ",", "op", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "FALSE", ";", "ind", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "reload_completed", "&&", "(", "LABEL_REF_P", "(", "ind", ")", "||", "(", "GET_CODE", "(", "ind", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "TRUE", ";", "if", "(", "REG_P", "(", "ind", ")", ")", "return", "arm_address_register_rtx_p", "(", "ind", ",", "0", ")", ";", "if", "(", "wb_level", ">", "0", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "POST_INC", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_DEC", "||", "(", "wb_level", ">", "1", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "ind", ")", "==", "POST_DEC", ")", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ";", "if", "(", "wb_level", ">", "1", "&&", "(", "GET_CODE", "(", "ind", ")", "==", "POST_MODIFY", "||", "GET_CODE", "(", "ind", ")", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "ind", ",", "0", ")", ")", ")", "ind", "=", "XEXP", "(", "ind", ",", "1", ")", ";", "int", "factor", "=", "MIN", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ",", "4", ")", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "VOIDmode", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", ",", "-", "255", "*", "factor", ",", "255", "*", "factor", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&", "(", "factor", "-", "1", ")", ")", "==", "0", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "valid", "coprocessor", "memory", "address", "pattern", ".", "WB", "level", "is", "2", "if", "full", "writeback", "address", "modes", "are", "allowed", ",", "1", "if", "limited", "writeback", "address", "modes", "(", "POST_INC", "and", "PRE_DEC", ")", "are", "allowed", "and", "0", "if", "no", "writeback", "at", "all", "is", "supported", "." ]

[ "arm", "0", "1", "2", "0", "0", "0", "0", "0", "1", "0", "0", "1", "0", "0", "1", "0", "0", "1", "1", "0", "0", "1", "4", "0", "0", "1", "1", "255", "255", "1", "1", "0" ]

[]

[ "<s>", "Register", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "MovOpc", "=", "ST", ".", "enableFlatScratch", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32", ":", "AMDGPU", "::", "V_MOV_B32_e32", ";", "Register", "BaseReg", "=", "MRI", ".", "createVirtualRegister", "(", "ST", ".", "enableFlatScratch", "(", ")", "?", "&", "AMDGPU", "::", "SReg_32_XEXEC_HIRegClass", ":", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "MovOpc", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", "BaseReg", ";", "}", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "Register", "FIReg", "=", "MRI", ".", "createVirtualRegister", "(", "ST", ".", "enableFlatScratch", "(", ")", "?", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ":", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "MovOpc", ")", ",", "FIReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "if", "(", "ST", ".", "enableFlatScratch", "(", ")", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_I32", ")", ",", "BaseReg", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ";", "return", "BaseReg", ";", "}", "TII", "->", "getAddNoCarry", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "BaseReg", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ".", "addImm", "(", "0", ")", ";", "return", "BaseReg", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::S_MOV_B32", "AMDGPU::V_MOV_B32_e32", "AMDGPU::SReg_32_XEXEC_HIRegClass", "AMDGPU::VGPR_32RegClass", "0", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::S_MOV_B32", "AMDGPU::S_ADD_I32", "0" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "CommentStream", ")", "HasCustomInstComment", "=", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "if", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "OS", "<<", "\"\\tlock\\n\"", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "X86", "::", "Mode64Bit", ")", "!=", "0", ")", "{", "OS", "<<", "\"\\tcallq\\t\"", ";", "printPCRelImm", "(", "MI", ",", "0", ",", "OS", ")", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86II::LOCK", "\"\\tlock\\n\"", "X86::CALLpcrel32", "X86::Mode64Bit", "0", "\"\\tcallq\\t\"", "0" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a condition expression\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "Cond", "[", "1", "]", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "Cond", "[", "1", "]", ".", "isReg", "(", ")", "&&", "MRI", ".", "getRegClass", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", "==", "&", "WebAssembly", "::", "EXNREFRegClass", ")", "return", "true", ";", "Cond", ".", "front", "(", ")", "=", "MachineOperand", "::", "CreateImm", "(", "!", "Cond", ".", "front", "(", ")", ".", "getImm", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "2", "\"Expected a flag and a condition expression\"", "1", "1", "1", "WebAssembly::EXNREFRegClass" ]

[]

[ "<s>", "DecodeStatus", "MipsDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Region", ",", "Address", ",", "Size", ",", "Insn", ",", "isBigEndian", ",", "IsMicroMips", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "IsMicroMips", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableMicroMips32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "if", "(", "isMips32r6", "(", ")", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableMips32r6_64r632", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "Result", "=", "decodeInstruction", "(", "DecoderTableMips32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "fits_dispatch_window", "(", "rtx_insn", "*", "insn", ")", "{", "dispatch_windows", "*", "window_list", "=", "dispatch_window_list", ";", "dispatch_windows", "*", "window_list_next", "=", "dispatch_window_list", "->", "next", ";", "unsigned", "int", "num_restrict", ";", "enum", "dispatch_group", "group", "=", "get_insn_group", "(", "insn", ")", ";", "enum", "insn_path", "path", "=", "get_insn_path", "(", "insn", ")", ";", "int", "sum", ";", "if", "(", "group", "==", "disp_jcc", "||", "group", "==", "disp_cmp", ")", "return", "false", ";", "if", "(", "group", "==", "disp_no_group", "||", "group", "==", "disp_branch", ")", "return", "true", ";", "if", "(", "window_list_next", ")", "window_list", "=", "window_list_next", ";", "if", "(", "window_list", "->", "window_num", "==", "1", ")", "{", "sum", "=", "window_list", "->", "prev", "->", "window_size", "+", "window_list", "->", "window_size", ";", "if", "(", "sum", "==", "32", "||", "(", "ix86_min_insn_size", "(", "insn", ")", "+", "sum", ")", ">=", "48", ")", "return", "true", ";", "}", "num_restrict", "=", "count_num_restricted", "(", "insn", ",", "window_list", ")", ";", "if", "(", "num_restrict", ">", "num_allowable_groups", "[", "group", "]", ")", "return", "false", ";", "if", "(", "window_list", "->", "window_num", "==", "0", ")", "{", "if", "(", "path", "==", "path_double", "&&", "(", "window_list", "->", "num_uops", "+", "2", ")", ">", "MAX_INSN", ")", "return", "false", ";", "else", "if", "(", "path", "!=", "path_single", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "insn", "satisfies", "dispatch", "rules", "on", "the", "last", "window", "scheduled", "." ]

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

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "char", "*", "output_mov_long_double_arm_from_arm", "(", "rtx", "*", "operands", ")", "{", "int", "dest_start", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "int", "src_start", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "rtx", "ops", "[", "2", "]", ";", "int", "i", ";", "if", "(", "dest_start", "<", "src_start", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "ops", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "dest_start", "+", "i", ")", ";", "ops", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "src_start", "+", "i", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %1\"", ",", "ops", ")", ";", "}", "}", "else", "{", "for", "(", "i", "=", "2", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "ops", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "dest_start", "+", "i", ")", ";", "ops", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "src_start", "+", "i", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %1\"", ",", "ops", ")", ";", "}", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "move", "from", "arm", "registers", "to", "arm", "registers", "of", "a", "long", "double", "OPERANDS", "[", "0", "]", "is", "the", "destination", ".", "OPERANDS", "[", "1", "]", "is", "the", "source", "." ]

[ "arm", "0", "1", "2", "0", "3", "0", "1", "\"mov%?\\t%0, %1\"", "2", "0", "0", "1", "\"mov%?\\t%0, %1\"", "\"\"" ]

[]

[ "<s>", "const", "char", "*", "output_jump_label_table", "(", ")", "{", "int", "i", ";", "if", "(", "pool_size", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.align 2\\n\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "pool_size", ";", "i", "++", ")", "{", "pool_node", "*", "p", "=", "&", "pool_vector", "[", "i", "]", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "p", "->", "label", ")", ")", ";", "output_asm_insn", "(", "\".long\t%O0\"", ",", "&", "p", "->", "value", ")", ";", "}", "pool_size", "=", "0", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Dump", "out", "any", "constants", "accumulated", "in", "the", "final", "pass", ".", "These", "will", "only", "be", "labels", "." ]

[ "sh", "\"\\t.align 2\\n\"", "0", "\"L\"", "\".long\t%O0\"", "0", "\"\"" ]

[]

[ "<s>", "bool", "alpha_legitimate_constant_p", "(", "rtx", "x", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "HOST_WIDE_INT", "i0", ",", "i1", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_VECTOR", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_INT", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_INT", ":", "do_integer", ":", "if", "(", "TARGET_BUILD_CONSTANTS", ")", "return", "true", ";", "alpha_extract_integer", "(", "x", ",", "&", "i0", ",", "&", "i1", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", "||", "i1", "==", "(", "-", "i0", "<", "0", ")", ")", "return", "alpha_emit_set_const_1", "(", "x", ",", "mode", ",", "i0", ",", "3", ",", "true", ")", "!=", "NULL", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "LEGITIMATE_CONSTANT_P", ".", "This", "is", "all", "constants", "for", "which", "we", "are", "willing", "to", "load", "the", "value", "into", "a", "register", "via", "a", "move", "pattern", ".", "Normally", "this", "is", "all", "symbolic", "constants", ",", "integral", "constants", "that", "take", "three", "or", "fewer", "instructions", ",", "and", "floating-point", "zero", "." ]

[ "alpha", "8", "64", "0", "3" ]

[]

[ "<s>", "rtx", "mmix_get_hard_reg_initial_val", "(", "enum", "machine_mode", "mode", ",", "int", "regno", ")", "{", "return", "get_hard_reg_initial_val", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "get_hard_reg_initial_val", "since", "integrate.h", "is", "n't", "included", "from", "insn-emit.cc", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "void", "block_move_sequence", "(", "rtx", "dst_mem", ",", "rtx", "src_mem", ",", "int", "size", ",", "int", "align", ")", "{", "rtx", "temp", "[", "2", "]", ";", "machine_mode", "mode", "[", "2", "]", ";", "int", "amount", "[", "2", "]", ";", "bool", "active", "[", "2", "]", ";", "int", "phase", "=", "0", ";", "int", "next", ";", "int", "offset_ld", "=", "0", ";", "int", "offset_st", "=", "0", ";", "rtx", "x", ";", "x", "=", "XEXP", "(", "dst_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "dst_mem", "=", "replace_equiv_address", "(", "dst_mem", ",", "x", ")", ";", "}", "x", "=", "XEXP", "(", "src_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "src_mem", "=", "replace_equiv_address", "(", "src_mem", ",", "x", ")", ";", "}", "active", "[", "0", "]", "=", "active", "[", "1", "]", "=", "false", ";", "do", "{", "next", "=", "phase", ";", "phase", "^=", "1", ";", "if", "(", "size", ">", "0", ")", "{", "int", "next_amount", ";", "next_amount", "=", "(", "size", ">=", "4", "?", "4", ":", "(", "size", ">=", "2", "?", "2", ":", "1", ")", ")", ";", "next_amount", "=", "MIN", "(", "next_amount", ",", "align", ")", ";", "amount", "[", "next", "]", "=", "next_amount", ";", "mode", "[", "next", "]", "=", "mode_from_align", "[", "next_amount", "]", ";", "temp", "[", "next", "]", "=", "gen_reg_rtx", "(", "mode", "[", "next", "]", ")", ";", "x", "=", "adjust_address", "(", "src_mem", ",", "mode", "[", "next", "]", ",", "offset_ld", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", "[", "next", "]", ",", "x", ")", ")", ";", "offset_ld", "+=", "next_amount", ";", "size", "-=", "next_amount", ";", "active", "[", "next", "]", "=", "true", ";", "}", "if", "(", "active", "[", "phase", "]", ")", "{", "active", "[", "phase", "]", "=", "false", ";", "x", "=", "adjust_address", "(", "dst_mem", ",", "mode", "[", "phase", "]", ",", "offset_st", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "temp", "[", "phase", "]", ")", ")", ";", "offset_st", "+=", "amount", "[", "phase", "]", ";", "}", "}", "while", "(", "active", "[", "next", "]", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "perform", "a", "block", "move", "with", "an", "offset", "sequence", "of", "ld/st", "instructions", "(", "...", ",", "ld", "0", ",", "st", "1", ",", "ld", "1", ",", "st", "0", ",", "...", ")", ".", "SIZE", "and", "ALIGN", "are", "known", "constants", ".", "DEST", "and", "SRC", "are", "registers", ".", "OFFSET", "is", "the", "known", "starting", "point", "for", "the", "output", "pattern", "." ]

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

[]

[ "<s>", "static", "rtx", "ix86_erase_embedded_rounding", "(", "rtx", "pat", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "INSN", ")", "pat", "=", "PATTERN", "(", "pat", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", ";", "if", "(", "XVECLEN", "(", "pat", ",", "0", ")", "==", "2", ")", "{", "rtx", "p0", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "rtx", "p1", "=", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "p0", ")", "==", "SET", "&&", "GET_CODE", "(", "p1", ")", "==", "UNSPEC", "&&", "XINT", "(", "p1", ",", "1", ")", "==", "UNSPEC_EMBEDDED_ROUNDING", ")", ";", "return", "p0", ";", "}", "else", "{", "rtx", "*", "res", "=", "XALLOCAVEC", "(", "rtx", ",", "XVECLEN", "(", "pat", ",", "0", ")", ")", ";", "int", "i", "=", "0", ";", "int", "j", "=", "0", ";", "for", "(", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "++", "i", ")", "{", "rtx", "elem", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "elem", ")", "!=", "UNSPEC", "||", "XINT", "(", "elem", ",", "1", ")", "!=", "UNSPEC_EMBEDDED_ROUNDING", ")", "res", "[", "j", "++", "]", "=", "elem", ";", "}", "gcc_assert", "(", "j", ">=", "XVECLEN", "(", "pat", ",", "0", ")", "-", "1", ")", ";", "return", "gen_rtx_PARALLEL", "(", "GET_MODE", "(", "pat", ")", ",", "gen_rtvec_v", "(", "j", ",", "res", ")", ")", ";", "}", "}", "</s>" ]

[ "Transform", "pattern", "of", "following", "layout", ":", "(", "parallel", "[", "set", "(", "A", "B", ")", "(", "unspec", "[", "C", "]", "UNSPEC_EMBEDDED_ROUNDING", ")", "]", ")", "]", ")", "into", ":", "(", "set", "(", "A", "B", ")", ")", "Or", ":", "(", "parallel", "[", "A", "B", "...", "(", "unspec", "[", "C", "]", "UNSPEC_EMBEDDED_ROUNDING", ")", "...", "]", ")", "into", ":", "(", "parallel", "[", "A", "B", "...", "]", ")" ]

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

[]

[ "<s>", "void", "MipsSEInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MipsABIInfo", "ABI", "=", "Subtarget", ".", "getABI", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "ADDiu", "=", "ABI", ".", "GetPtrAddiuOp", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "unsigned", "Opc", "=", "ABI", ".", "GetPtrAdduOp", "(", ")", ";", "if", "(", "Amount", "<", "0", ")", "{", "Opc", "=", "ABI", ".", "GetPtrSubuOp", "(", ")", ";", "Amount", "=", "-", "Amount", ";", "}", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "nullptr", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "0", "16", "0" ]

[]

[ "<s>", "static", "int", "get_symbol_alignment", "(", "rtx", "x", ")", "{", "tree", "decl", "=", "NULL_TREE", ";", "int", "align", "=", "0", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "break", ";", "case", "CONST", ":", "return", "get_symbol_alignment", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PLUS", ":", "gcc_assert", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "return", "get_symbol_alignment", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "default", ":", "return", "0", ";", "}", "if", "(", "decl", ")", "align", "=", "DECL_ALIGN", "(", "decl", ")", ";", "align", "=", "align", "/", "BITS_PER_UNIT", ";", "return", "align", ";", "}", "</s>" ]

[ "Given", "a", "symbol", "RTX", "(", "const", "(", "symb", "<", "+", "const_int", ">", ")", ",", "returns", "its", "alignment", "." ]

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

[]

[ "<s>", "void", "riscv_expand_prologue", "(", "void", ")", "{", "struct", "riscv_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "HOST_WIDE_INT", "size", "=", "frame", "->", "total_size", ";", "unsigned", "mask", "=", "frame", "->", "mask", ";", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", ")", "{", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "0", ";", "return", ";", "}", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "riscv_use_save_libcall", "(", "frame", ")", ")", "{", "rtx", "dwarf", "=", "NULL_RTX", ";", "dwarf", "=", "riscv_adjust_libcall_cfi_prologue", "(", ")", ";", "frame", "->", "mask", "=", "0", ";", "size", "-=", "frame", "->", "save_libcall_adjustment", ";", "insn", "=", "emit_insn", "(", "gen_gpr_save", "(", "GEN_INT", "(", "mask", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "}", "if", "(", "(", "frame", "->", "mask", "|", "frame", "->", "fmask", ")", "!=", "0", ")", "{", "HOST_WIDE_INT", "step1", "=", "MIN", "(", "size", ",", "riscv_first_stack_step", "(", "frame", ")", ")", ";", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "step1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "size", "-=", "step1", ";", "riscv_for_each_saved_reg", "(", "size", ",", "riscv_save_reg", ")", ";", "}", "frame", "->", "mask", "=", "mask", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "gen_add3_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "frame", "->", "hard_frame_pointer_offset", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "riscv_emit_stack_tie", "(", ")", ";", "}", "if", "(", "size", ">", "0", ")", "{", "if", "(", "SMALL_OPERAND", "(", "-", "size", ")", ")", "{", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "}", "else", "{", "riscv_emit_move", "(", "RISCV_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "RISCV_PROLOGUE_TEMP", "(", "Pmode", ")", ")", ")", ";", "insn", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "size", ")", ";", "insn", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "insn", ")", ";", "riscv_set_frame_expr", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "the", "``", "prologue", "''", "pattern", "." ]

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

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitGlobals", "(", "const", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str2", ";", "raw_svector_ostream", "OS2", "(", "Str2", ")", ";", "emitDeclarations", "(", "M", ",", "OS2", ")", ";", "SmallVector", "<", "const", "GlobalVariable", "*", ",", "8", ">", "Globals", ";", "DenseSet", "<", "const", "GlobalVariable", "*", ">", "GVVisited", ";", "DenseSet", "<", "const", "GlobalVariable", "*", ">", "GVVisiting", ";", "for", "(", "const", "GlobalVariable", "&", "I", ":", "M", ".", "globals", "(", ")", ")", "VisitGlobalVariableForEmission", "(", "&", "I", ",", "Globals", ",", "GVVisited", ",", "GVVisiting", ")", ";", "assert", "(", "GVVisited", ".", "size", "(", ")", "==", "M", ".", "getGlobalList", "(", ")", ".", "size", "(", ")", "&&", "\"Missed a global variable\"", ")", ";", "assert", "(", "GVVisiting", ".", "size", "(", ")", "==", "0", "&&", "\"Did not fully process a global variable\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Globals", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "printModuleLevelGV", "(", "Globals", "[", "i", "]", ",", "OS2", ")", ";", "OS2", "<<", "'\\n'", ";", "OutStreamer", "->", "EmitRawText", "(", "OS2", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitGlobals", "-", "Emit", "all", "of", "the", "global", "variables", "to", "memory", ",", "storing", "their", "addresses", "into", "GlobalAddress", "." ]

[ "NVPTX", "NVPTX", "128", "8", "\"Missed a global variable\"", "0", "\"Did not fully process a global variable\"", "0" ]

[]

[ "<s>", "void", "FISCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "FISC", "::", "ADDri", ":", "case", "FISC", "::", "LDR", ":", "case", "FISC", "::", "LDRB", ":", "case", "FISC", "::", "LDRH", ":", "case", "FISC", "::", "LDRSW", ":", "case", "FISC", "::", "LDRXR", ":", "case", "FISC", "::", "LDRR", ":", "case", "FISC", "::", "LDRBR", ":", "case", "FISC", "::", "LDRHR", ":", "case", "FISC", "::", "LDRSWR", ":", "case", "FISC", "::", "LDRXRR", ":", "case", "FISC", "::", "STR", ":", "case", "FISC", "::", "STRB", ":", "case", "FISC", "::", "STRH", ":", "case", "FISC", "::", "STRW", ":", "case", "FISC", "::", "STRXR", ":", "case", "FISC", "::", "STRR", ":", "case", "FISC", "::", "STRBR", ":", "case", "FISC", "::", "STRHR", ":", "case", "FISC", "::", "STRWR", ":", "case", "FISC", "::", "STRXRR", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "FISC", "::", "SP", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "0", "FISC::ADDri", "FISC::LDR", "FISC::LDRB", "FISC::LDRH", "FISC::LDRSW", "FISC::LDRXR", "FISC::LDRR", "FISC::LDRBR", "FISC::LDRHR", "FISC::LDRSWR", "FISC::LDRXRR", "FISC::STR", "FISC::STRB", "FISC::STRH", "FISC::STRW", "FISC::STRXR", "FISC::STRR", "FISC::STRBR", "FISC::STRHR", "FISC::STRWR", "FISC::STRXRR", "1", "FISC::SP" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "MCS51_EXPAND_PSEUDO_NAME", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51" ]

[]

[ "<s>", "static", "void", "recombine_lvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "MEM", ")", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "rtx", "and_operation", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ")", ";", "if", "(", "and_operation", "!=", "0", ")", "{", "df_ref", "def", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "XEXP", "(", "mem", ",", "0", ")", "=", "and_operation", ";", "SET_SRC", "(", "body", ")", "=", "mem", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"lvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "load", "for", "an", "lvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "1", "\"lvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "static", "const", "char", "*", "fp_const_from_val", "(", "REAL_VALUE_TYPE", "*", "r", ")", "{", "if", "(", "!", "fp_consts_inited", ")", "init_fp_table", "(", ")", ";", "gcc_assert", "(", "real_equal", "(", "r", ",", "&", "value_fp0", ")", ")", ";", "return", "\"0\"", ";", "}", "</s>" ]

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

[ "arm", "\"0\"" ]

[]

[ "<s>", "void", "MandarinTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "N", ")", ";", "RTLIB", "::", "Libcall", "libCall", "=", "RTLIB", "::", "UNKNOWN_LIBCALL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "Mandarin", "\"Do not know how to custom type legalize this operation!\"" ]

[]

[ "<s>", "MCSection", "*", "AMDGPUTargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "SK", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "StringRef", "SectionName", "=", "GO", "->", "getSection", "(", ")", ";", "if", "(", "SectionName", ".", "startswith", "(", "\".AMDGPU.metadata.\"", ")", ")", "SK", "=", "SectionKind", "::", "getMetadata", "(", ")", ";", "return", "TargetLoweringObjectFileELF", "::", "getExplicitSectionGlobal", "(", "GO", ",", "SK", ",", "TM", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "AMDGPU", "AMDGPU", "\".AMDGPU.metadata.\"" ]

[]

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

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

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

[]

[ "<s>", "long", "rs6000_const_f32_to_i32", "(", "rtx", "operand", ")", "{", "long", "value", ";", "const", "struct", "real_value", "*", "rv", "=", "CONST_DOUBLE_REAL_VALUE", "(", "operand", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "operand", ")", "==", "SFmode", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "rv", ",", "value", ")", ";", "return", "value", ";", "}", "</s>" ]

[ "Convert", "a", "SFmode", "constant", "to", "the", "integer", "bit", "pattern", "." ]

[ "rs6000" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Lower control flow pseudo instructions\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Lower control flow pseudo instructions\"" ]

[]

[ "<s>", "static", "bool", "aarch64_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "TARGET_SIMD", "&&", "aarch64_vect_struct_mode_p", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", "&&", "aarch64_simd_valid_immediate", "(", "x", ",", "mode", ",", "false", ",", "NULL", ")", ")", "||", "CONST_INT_P", "(", "x", ")", "||", "aarch64_valid_floating_const", "(", "mode", ",", "x", ")", ")", "return", "!", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", "&&", "aarch64_valid_symref", "(", "XEXP", "(", "x", ",", "0", ")", ",", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "return", "true", ";", "return", "aarch64_constant_address_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "hook", ".", "Return", "true", "for", "constants", "that", "should", "be", "rematerialized", "rather", "than", "spilled", "." ]

[ "aarch64", "0", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ")", "const", "{", "if", "(", "getEffectiveCallingConv", "(", "CallConv", ",", "isVarArg", ")", "!=", "CallingConv", "::", "ARM_AAPCS_VFP", ")", "return", "false", ";", "HABaseType", "Base", "=", "HA_UNKNOWN", ";", "uint64_t", "Members", "=", "0", ";", "bool", "result", "=", "isHomogeneousAggregate", "(", "Ty", ",", "Base", ",", "Members", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"isHA: \"", "<<", "result", "<<", "\" \"", ";", "Ty", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

[ "ARM", "ARM", "ARM", "0", "\"isHA: \"", "\" \"", "\"\\n\"" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "case", "Mips", "::", "DSLL_MM64R6", ":", "case", "Mips", "::", "DSRL_MM64R6", ":", "case", "Mips", "::", "DSRA_MM64R6", ":", "case", "Mips", "::", "DROTR_MM64R6", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "DINS", ":", "LowerDins", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BOVC", ":", "case", "Mips", "::", "BOVC_MMR6", ":", "case", "Mips", "::", "BNVC", ":", "case", "Mips", "::", "BNVC_MMR6", ":", "LowerCompactBranch", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::DSLL_MM64R6", "Mips::DSRL_MM64R6", "Mips::DSRA_MM64R6", "Mips::DROTR_MM64R6", "Mips::DINS", "Mips::BEQC", "Mips::BNEC", "Mips::BOVC", "Mips::BOVC_MMR6", "Mips::BNVC", "Mips::BNVC_MMR6", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "\"Desc.getSize() returns 0\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SystemZTargetLowering", "::", "getScratchRegisters", "(", "CallingConv", "::", "ID", ")", "const", "{", "static", "const", "MCPhysReg", "ScratchRegs", "[", "]", "=", "{", "SystemZ", "::", "R0D", ",", "SystemZ", "::", "R1D", ",", "SystemZ", "::", "R14D", ",", "0", "}", ";", "return", "ScratchRegs", ";", "}", "</s>" ]

[ "Returns", "a", "0", "terminated", "array", "of", "registers", "that", "can", "be", "safely", "used", "as", "scratch", "registers", "." ]

[ "SystemZ", "SystemZ", "SystemZ::R0D", "SystemZ::R1D", "SystemZ::R14D", "0" ]

[]

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

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

[ "AMDGPU", "\"<register \"", "\" mods: \"", "\"<expr \"" ]

[]

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

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "static", "bool", "arm_align_anon_bitfield", "(", "void", ")", "{", "return", "TARGET_AAPCS_BASED", ";", "}", "</s>" ]

[ "AAPCS", "requires", "that", "anonymous", "bitfields", "affect", "structure", "alignment", "." ]

[ "arm" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "bool", "Vector", "=", "(", "ClassID", "==", "1", ")", ";", "if", "(", "Vector", ")", "{", "return", "0", ";", "}", "return", "12", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "XCore", "1", "0", "12" ]

[]

[ "<s>", "TargetTransformInfo", "MipsTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "if", "(", "Subtarget", "->", "allowMixed16_32", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"No Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "}", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "MipsTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"No Target Transform Info Pass Added\\n\"", "\"Target Transform Info Pass Added\\n\"", "Mips" ]

[]

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

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

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

[]

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

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

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

[]

[ "<s>", "opt_machine_mode", "aarch64_vq_mode", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DFmode", ":", "return", "V2DFmode", ";", "case", "E_SFmode", ":", "return", "V4SFmode", ";", "case", "E_HFmode", ":", "return", "V8HFmode", ";", "case", "E_BFmode", ":", "return", "V8BFmode", ";", "case", "E_SImode", ":", "return", "V4SImode", ";", "case", "E_HImode", ":", "return", "V8HImode", ";", "case", "E_QImode", ":", "return", "V16QImode", ";", "case", "E_DImode", ":", "return", "V2DImode", ";", "default", ":", "return", "opt_machine_mode", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "128-bit", "Advanced", "SIMD", "vector", "mode", "for", "element", "mode", "MODE", ",", "if", "it", "exists", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "rs6000_emit_swdivdf", "(", "rtx", "res", ",", "rtx", "n", ",", "rtx", "d", ")", "{", "rtx", "x0", ",", "e0", ",", "e1", ",", "e2", ",", "y1", ",", "y2", ",", "y3", ",", "u0", ",", "v0", ",", "one", ";", "x0", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "e0", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "e1", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "e2", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "y1", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "y2", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "y3", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "u0", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "v0", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "one", "=", "force_reg", "(", "DFmode", ",", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "dconst1", ",", "DFmode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x0", ",", "gen_rtx_UNSPEC", "(", "DFmode", ",", "gen_rtvec", "(", "1", ",", "d", ")", ",", "UNSPEC_FRES", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e0", ",", "gen_rtx_MINUS", "(", "DFmode", ",", "one", ",", "gen_rtx_MULT", "(", "SFmode", ",", "d", ",", "x0", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "y1", ",", "gen_rtx_PLUS", "(", "DFmode", ",", "gen_rtx_MULT", "(", "DFmode", ",", "e0", ",", "x0", ")", ",", "x0", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e1", ",", "gen_rtx_MULT", "(", "DFmode", ",", "e0", ",", "e0", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "y2", ",", "gen_rtx_PLUS", "(", "DFmode", ",", "gen_rtx_MULT", "(", "DFmode", ",", "e1", ",", "y1", ")", ",", "y1", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e2", ",", "gen_rtx_MULT", "(", "DFmode", ",", "e1", ",", "e1", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "y3", ",", "gen_rtx_PLUS", "(", "DFmode", ",", "gen_rtx_MULT", "(", "DFmode", ",", "e2", ",", "y2", ")", ",", "y2", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "u0", ",", "gen_rtx_MULT", "(", "DFmode", ",", "n", ",", "y3", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "v0", ",", "gen_rtx_MINUS", "(", "DFmode", ",", "n", ",", "gen_rtx_MULT", "(", "DFmode", ",", "d", ",", "u0", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "res", ",", "gen_rtx_PLUS", "(", "DFmode", ",", "gen_rtx_MULT", "(", "DFmode", ",", "v0", ",", "y3", ")", ",", "u0", ")", ")", ")", ";", "}", "</s>" ]

[ "Newton-Raphson", "approximation", "of", "double-precision", "floating", "point", "divide", "n/d", ".", "Assumes", "no", "trapping", "math", "and", "finite", "arguments", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "bool", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "SMRange", "Range", "=", "None", ")", "{", "return", "getParser", "(", ")", ".", "Warning", "(", "L", ",", "Msg", ",", "Range", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "mips_linked_madd_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "enum", "attr_accum_in", "accum_in", ";", "int", "accum_in_opnum", ";", "rtx", "accum_in_op", ";", "if", "(", "recog_memoized", "(", "in_insn", ")", "<", "0", ")", "return", "false", ";", "accum_in", "=", "get_attr_accum_in", "(", "in_insn", ")", ";", "if", "(", "accum_in", "==", "ACCUM_IN_NONE", ")", "return", "false", ";", "accum_in_opnum", "=", "accum_in", "-", "ACCUM_IN_0", ";", "extract_insn", "(", "in_insn", ")", ";", "gcc_assert", "(", "accum_in_opnum", "<", "recog_data", ".", "n_operands", ")", ";", "accum_in_op", "=", "recog_data", ".", "operand", "[", "accum_in_opnum", "]", ";", "return", "reg_set_p", "(", "accum_in_op", ",", "out_insn", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "a", "multiply-add", "or", "multiply-subtract", "instruction", "and", "PREV", "assigns", "to", "the", "accumulator", "operand", "." ]

[ "mips", "0" ]

[]

[ "<s>", "rtx", "thumb_legitimize_address", "(", "rtx", "x", ",", "rtx", "orig_x", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "32", "*", "GET_MODE_SIZE", "(", "mode", ")", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "xop1", ")", ";", "if", "(", "optimize_size", "&&", "offset", ">=", "0", "&&", "offset", "<", "256", "+", "31", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "HOST_WIDE_INT", "delta", ";", "if", "(", "offset", ">=", "256", ")", "delta", "=", "offset", "-", "(", "256", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "else", "if", "(", "offset", "<", "32", "*", "GET_MODE_SIZE", "(", "mode", ")", "+", "8", ")", "delta", "=", "31", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "delta", "=", "offset", "&", "(", "~", "31", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "xop0", "=", "force_operand", "(", "plus_constant", "(", "Pmode", ",", "xop0", ",", "offset", "-", "delta", ")", ",", "NULL_RTX", ")", ";", "x", "=", "plus_constant", "(", "Pmode", ",", "xop0", ",", "delta", ")", ";", "}", "else", "if", "(", "offset", "<", "0", "&&", "offset", ">", "-", "256", ")", "x", "=", "force_operand", "(", "x", ",", "NULL_RTX", ")", ";", "else", "{", "xop1", "=", "force_reg", "(", "SImode", ",", "xop1", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "SImode", ",", "xop0", ",", "xop1", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "s_register_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "SImode", ")", "&&", "!", "s_register_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "SImode", ")", ")", "{", "rtx", "xop0", "=", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "SImode", ",", "xop0", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "rtx", "new_x", "=", "legitimize_pic_address", "(", "orig_x", ",", "mode", ",", "NULL_RTX", ")", ";", "if", "(", "new_x", "!=", "orig_x", ")", "x", "=", "new_x", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "Thumb", "address", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", "." ]

[ "arm", "1", "1", "32", "1", "0", "0", "1", "0", "256", "31", "256", "256", "32", "8", "31", "31", "0", "256", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "save_entry", "*", "sh5_schedule_saves", "(", "HARD_REG_SET", "*", "live_regs_mask", ",", "save_schedule", "*", "schedule", ",", "int", "offset_base", ")", "{", "int", "align", ",", "i", ";", "save_entry", "*", "entry", "=", "schedule", "->", "entries", ";", "int", "tmpx", "=", "0", ";", "int", "offset", ";", "if", "(", "!", "current_function_interrupt", ")", "for", "(", "i", "=", "FIRST_GENERAL_REG", ";", "tmpx", "<", "MAX_TEMPS", "&&", "i", "<=", "LAST_GENERAL_REG", ";", "i", "++", ")", "if", "(", "call_really_used_regs", "[", "i", "]", "&&", "!", "fixed_regs", "[", "i", "]", "&&", "i", "!=", "PR_MEDIA_REG", "&&", "!", "FUNCTION_ARG_REGNO_P", "(", "i", ")", "&&", "i", "!=", "FIRST_RET_REG", "&&", "!", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", "&&", "i", "==", "STATIC_CHAIN_REGNUM", ")", "&&", "!", "(", "current_function_calls_eh_return", "&&", "(", "i", "==", "EH_RETURN_STACKADJ_REGNO", "||", "(", "(", "unsigned", ")", "i", ">=", "EH_RETURN_DATA_REGNO", "(", "0", ")", "&&", "(", "unsigned", ")", "i", "<=", "EH_RETURN_DATA_REGNO", "(", "3", ")", ")", ")", ")", ")", "schedule", "->", "temps", "[", "tmpx", "++", "]", "=", "i", ";", "entry", "->", "reg", "=", "-", "1", ";", "entry", "->", "mode", "=", "VOIDmode", ";", "entry", "->", "offset", "=", "offset_base", ";", "entry", "++", ";", "offset", "=", "offset_base", ";", "for", "(", "align", "=", "1", ";", "align", ">=", "0", ";", "align", "--", ")", "{", "for", "(", "i", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "i", ")", ")", "{", "enum", "machine_mode", "mode", "=", "REGISTER_NATURAL_MODE", "(", "i", ")", ";", "int", "reg", "=", "i", ";", "if", "(", "current_function_interrupt", ")", "{", "if", "(", "TARGET_REGISTER_P", "(", "i", ")", ")", "continue", ";", "if", "(", "GENERAL_REGISTER_P", "(", "i", ")", ")", "mode", "=", "DImode", ";", "}", "if", "(", "mode", "==", "SFmode", "&&", "(", "i", "%", "2", ")", "==", "1", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_REGISTER_P", "(", "i", ")", "&&", "(", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "(", "i", "^", "1", ")", ")", ")", ")", "{", "mode", "=", "DFmode", ";", "i", "--", ";", "reg", "--", ";", "}", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "%", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "==", "0", ")", "!=", "align", ")", "continue", ";", "if", "(", "current_function_interrupt", "&&", "GENERAL_REGISTER_P", "(", "i", ")", "&&", "tmpx", "<", "MAX_TEMPS", ")", "schedule", "->", "temps", "[", "tmpx", "++", "]", "=", "i", ";", "offset", "-=", "GET_MODE_SIZE", "(", "mode", ")", ";", "entry", "->", "reg", "=", "i", ";", "entry", "->", "mode", "=", "mode", ";", "entry", "->", "offset", "=", "offset", ";", "entry", "++", ";", "}", "if", "(", "align", "&&", "current_function_interrupt", ")", "for", "(", "i", "=", "LAST_TARGET_REG", ";", "i", ">=", "FIRST_TARGET_REG", ";", "i", "--", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "i", ")", ")", "{", "offset", "-=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "entry", "->", "reg", "=", "i", ";", "entry", "->", "mode", "=", "DImode", ";", "entry", "->", "offset", "=", "offset", ";", "entry", "++", ";", "}", "}", "entry", "->", "reg", "=", "-", "1", ";", "entry", "->", "mode", "=", "VOIDmode", ";", "entry", "->", "offset", "=", "offset", ";", "schedule", "->", "temps", "[", "tmpx", "]", "=", "-", "1", ";", "return", "entry", "-", "1", ";", "}", "</s>" ]

[ "Fill", "in", "SCHEDULE", "according", "to", "LIVE_REGS_MASK", ".", "If", "RESTORE", "is", "nonzero", ",", "use", "reverse", "order", ".", "Returns", "the", "last", "entry", "written", "to", "(", "not", "counting", "the", "delimiter", ")", ".", "OFFSET_BASE", "is", "a", "number", "to", "be", "added", "to", "all", "offset", "entries", "." ]

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

[]

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

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

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

[]

[ "<s>", "int", "mmix_starting_frame_offset", "(", ")", "{", "return", "(", "-", "8", "+", "(", "MMIX_CFUN_HAS_LANDING_PAD", "?", "-", "16", ":", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", "?", "-", "8", ":", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "STARTING_FRAME_OFFSET", "." ]

[ "mmix", "8", "16", "8", "0" ]

[]

[ "<s>", "void", "scalar_chain", "::", "mark_dual_mode_def", "(", "df_ref", "def", ")", "{", "gcc_assert", "(", "DF_REF_REG_DEF_P", "(", "def", ")", ")", ";", "bool", "reg_new", "=", "bitmap_set_bit", "(", "defs_conv", ",", "DF_REF_REGNO", "(", "def", ")", ")", ";", "if", "(", "!", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "!", "bitmap_set_bit", "(", "insns_conv", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", "&&", "!", "reg_new", ")", "return", ";", "n_integer_to_sse", "++", ";", "}", "else", "{", "if", "(", "!", "reg_new", ")", "return", ";", "n_sse_to_integer", "++", ";", "}", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Mark r%d def in insn %d as requiring both modes in chain #%d\\n\"", ",", "DF_REF_REGNO", "(", "def", ")", ",", "DF_REF_INSN_UID", "(", "def", ")", ",", "chain_id", ")", ";", "}", "</s>" ]

[ "For", "DImode", "conversion", ",", "mark", "register", "defined", "by", "DEF", "as", "requiring", "conversion", "." ]

[ "i386", "\" Mark r%d def in insn %d as requiring both modes in chain #%d\\n\"" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "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>", "static", "bool", "mips_cannot_force_const_mem", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "enum", "mips_symbol_type", "type", ";", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "return", "true", ";", "if", "(", "(", "CONST_INT_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "&&", "mips_legitimate_constant_p", "(", "mode", ",", "x", ")", ")", "return", "true", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "mips_symbolic_constant_p", "(", "base", ",", "SYMBOL_CONTEXT_LEA", ",", "&", "type", ")", ")", "{", "if", "(", "mips_use_pcrel_pool_p", "[", "(", "int", ")", "type", "]", ")", "return", "false", ";", "if", "(", "SMALL_INT", "(", "offset", ")", "&&", "mips_symbol_insns", "(", "type", ",", "MAX_MACHINE_MODE", ")", ">", "0", ")", "return", "true", ";", "if", "(", "TARGET_MIPS16_PCREL_LOADS", "&&", "mips_got_symbol_type_p", "(", "type", ")", ")", "return", "true", ";", "}", "if", "(", "tls_referenced_p", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "can", "not", "be", "forced", "into", "a", "constant", "pool", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "PlaceMarkers", "(", "MF", ",", "MLI", ",", "TII", ",", "MDT", ",", "MFI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "NVPTXTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "UP", ")", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "UP", ".", "Threshold", "/", "4", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "NVPTX", "NVPTX", "4" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "scalarizeVectorLoad", "(", "Load", ",", "DAG", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "BaseAlign", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "Size", ",", "SL", ",", "PtrVT", ")", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "HiAlign", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::ADD", "ISD::CONCAT_VECTORS", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FPW", "MSP430::MOV16rr", "MSP430::FPW", "MSP430::SPW", "MSP430::FPW", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "SDValue", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "IsVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "IsVolatile", ")", "return", "SDValue", "(", ")", ";", "if", "(", "auto", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitMemMem", "(", "DAG", ",", "DL", ",", "SystemZISD", "::", "MVC", ",", "SystemZISD", "::", "MVC_LOOP", ",", "Chain", ",", "Dst", ",", "Src", ",", "CSize", "->", "getZExtValue", "(", ")", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZISD::MVC", "SystemZISD::MVC_LOOP" ]

[]

[ "<s>", "virtual", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "shouldOutlineFromFunctionByDefault", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "Subtarget", ".", "isMClass", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "should", "be", "outlined", "from", "by", "default", "." ]

[ "ARM", "ARM" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeSelect", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "&", "TrueOp", ",", "unsigned", "&", "FalseOp", ",", "bool", "&", "Optimizable", ")", "const", "{", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "MOVCCr", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2MOVCCr", ")", "&&", "\"Unknown select instruction\"", ")", ";", "TrueOp", "=", "1", ";", "FalseOp", "=", "2", ";", "Cond", ".", "push_back", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", "->", "getOperand", "(", "4", ")", ")", ";", "Optimizable", "=", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "\"Unknown select instruction\"", "1", "2", "3", "4" ]

[]

[ "<s>", "virtual", "const", "AlphaRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha" ]

[]

[ "<s>", "MCSection", "*", "XCoreTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ",", "const", "GlobalObject", "*", "GO", ")", "const", "{", "if", "(", "Kind", ".", "isMergeableConst4", "(", ")", ")", "return", "MergeableConst4Section", ";", "if", "(", "Kind", ".", "isMergeableConst8", "(", ")", ")", "return", "MergeableConst8Section", ";", "if", "(", "Kind", ".", "isMergeableConst16", "(", ")", ")", "return", "MergeableConst16Section", ";", "assert", "(", "(", "Kind", ".", "isReadOnly", "(", ")", "||", "Kind", ".", "isReadOnlyWithRel", "(", ")", ")", "&&", "\"Unknown section kind\"", ")", ";", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "XCore", "XCore", "\"Unknown section kind\"" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vrev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "diff", ")", "{", "case", "7", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev64v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev64v8qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "3", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev32v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev32v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vrev64v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vrev64v4hi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "1", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev16v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev16v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vrev32v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vrev32v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vrev64v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vrev64v2si", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vrev64v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vrev64v2sf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "1", ")", "for", "(", "j", "=", "0", ";", "j", "<=", "diff", ";", "j", "+=", "1", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VREV", "insns", "." ]

[ "arm", "0", "7", "3", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "int", "crx_const_double_ok", "(", "rtx", "op", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "==", "DFmode", ")", "{", "REAL_VALUE_TYPE", "r", ";", "long", "l", "[", "2", "]", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "r", ",", "l", ")", ";", "return", "(", "UNSIGNED_INT_FITS_N_BITS", "(", "l", "[", "0", "]", ",", "4", ")", "&&", "UNSIGNED_INT_FITS_N_BITS", "(", "l", "[", "1", "]", ",", "4", ")", ")", "?", "1", ":", "0", ";", "}", "if", "(", "GET_MODE", "(", "op", ")", "==", "SFmode", ")", "{", "REAL_VALUE_TYPE", "r", ";", "long", "l", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "r", ",", "l", ")", ";", "return", "UNSIGNED_INT_FITS_N_BITS", "(", "l", ",", "4", ")", "?", "1", ":", "0", ";", "}", "return", "(", "UNSIGNED_INT_FITS_N_BITS", "(", "CONST_DOUBLE_LOW", "(", "op", ")", ",", "4", ")", "&&", "UNSIGNED_INT_FITS_N_BITS", "(", "CONST_DOUBLE_HIGH", "(", "op", ")", ",", "4", ")", ")", "?", "1", ":", "0", ";", "}", "</s>" ]

[ "Check", "if", "a", "const_double", "is", "ok", "for", "crx", "store-immediate", "instructions" ]

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

[]

[ "<s>", "rtx", "frv_split_minmax", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "minmax", "=", "operands", "[", "1", "]", ";", "rtx", "src1", "=", "operands", "[", "2", "]", ";", "rtx", "src2", "=", "operands", "[", "3", "]", ";", "rtx", "cc_reg", "=", "operands", "[", "4", "]", ";", "rtx", "cr_reg", "=", "operands", "[", "5", "]", ";", "rtx", "ret", ";", "enum", "rtx_code", "test_code", ";", "enum", "machine_mode", "cr_mode", "=", "GET_MODE", "(", "cr_reg", ")", ";", "start_sequence", "(", ")", ";", "switch", "(", "GET_CODE", "(", "minmax", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "SMIN", ":", "test_code", "=", "LT", ";", "break", ";", "case", "SMAX", ":", "test_code", "=", "GT", ";", "break", ";", "case", "UMIN", ":", "test_code", "=", "LTU", ";", "break", ";", "case", "UMAX", ":", "test_code", "=", "GTU", ";", "break", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "src1", ",", "src2", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cr_reg", ",", "gen_rtx_fmt_ee", "(", "test_code", ",", "GET_MODE", "(", "cr_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "src2", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src2", ")", "!=", "0", ")", "{", "gcc_assert", "(", "!", "rtx_equal_p", "(", "dest", ",", "src1", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "src2", ")", ";", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "cr_mode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src1", ")", ")", ")", ";", "}", "else", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src1", ")", ")", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "cr_mode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src1", ")", ")", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src2", ")", ")", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "cr_mode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src2", ")", ")", ")", ";", "}", "ret", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Split", "a", "min/max", "operation", "returning", "a", "SEQUENCE", "containing", "all", "of", "the", "insns", "." ]

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

[]

[ "<s>", "static", "rtx", "bpf_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", "ATTRIBUTE_UNUSED", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "if", "(", "code", "==", "BPF_BUILTIN_LOAD_BYTE", "||", "code", "==", "BPF_BUILTIN_LOAD_HALF", "||", "code", "==", "BPF_BUILTIN_LOAD_WORD", ")", "{", "enum", "insn_code", "abs_icode", "=", "(", "code", "==", "BPF_BUILTIN_LOAD_BYTE", "?", "CODE_FOR_ldabsb", ":", "code", "==", "BPF_BUILTIN_LOAD_HALF", "?", "CODE_FOR_ldabsh", ":", "CODE_FOR_ldabsw", ")", ";", "enum", "insn_code", "ind_icode", "=", "(", "code", "==", "BPF_BUILTIN_LOAD_BYTE", "?", "CODE_FOR_ldindb", ":", "code", "==", "BPF_BUILTIN_LOAD_HALF", "?", "CODE_FOR_ldindh", ":", "CODE_FOR_ldindw", ")", ";", "tree", "offset_arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "struct", "expand_operand", "ops", "[", "2", "]", ";", "create_input_operand", "(", "&", "ops", "[", "0", "]", ",", "expand_normal", "(", "offset_arg", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "offset_arg", ")", ")", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "const0_rtx", ",", "SImode", ")", ";", "if", "(", "!", "maybe_expand_insn", "(", "abs_icode", ",", "2", ",", "ops", ")", "&&", "!", "maybe_expand_insn", "(", "ind_icode", ",", "2", ",", "ops", ")", ")", "{", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "gen_rtx_REG", "(", "ops", "[", "0", "]", ".", "mode", ",", "BPF_R0", ")", ";", "}", "return", "gen_rtx_REG", "(", "ops", "[", "0", "]", ".", "mode", ",", "BPF_R0", ")", ";", "}", "else", "if", "(", "code", "==", "-", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ")", "{", "tree", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "if", "(", "arg", "==", "NULL_TREE", ")", "return", "NULL_RTX", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "==", "SSA_NAME", ")", "{", "gimple", "*", "def_stmt", "=", "SSA_NAME_DEF_STMT", "(", "arg", ")", ";", "if", "(", "is_gimple_assign", "(", "def_stmt", ")", ")", "arg", "=", "gimple_assign_rhs1", "(", "def_stmt", ")", ";", "else", "return", "expand_normal", "(", "arg", ")", ";", "}", "if", "(", "!", "is_attr_preserve_access", "(", "arg", ")", ")", "maybe_make_core_relo", "(", "arg", ",", "BPF_RELO_FIELD_BYTE_OFFSET", ")", ";", "return", "expand_normal", "(", "arg", ")", ";", "}", "else", "if", "(", "code", "==", "-", "BPF_BUILTIN_PRESERVE_FIELD_INFO", ")", "{", "tree", "src", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "kind_tree", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "unsigned", "HOST_WIDE_INT", "kind_val", "=", "0", ";", "if", "(", "tree_fits_uhwi_p", "(", "kind_tree", ")", ")", "kind_val", "=", "tree_to_uhwi", "(", "kind_tree", ")", ";", "else", "{", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "expand_normal", "(", "error_mark_node", ")", ";", "}", "enum", "btf_core_reloc_kind", "kind", "=", "(", "enum", "btf_core_reloc_kind", ")", "kind_val", ";", "if", "(", "TREE_CODE", "(", "src", ")", "==", "SSA_NAME", ")", "{", "gimple", "*", "def_stmt", "=", "SSA_NAME_DEF_STMT", "(", "src", ")", ";", "if", "(", "is_gimple_assign", "(", "def_stmt", ")", ")", "src", "=", "gimple_assign_rhs1", "(", "def_stmt", ")", ";", "}", "if", "(", "TREE_CODE", "(", "src", ")", "==", "ADDR_EXPR", ")", "src", "=", "TREE_OPERAND", "(", "src", ",", "0", ")", ";", "tree", "result", "=", "bpf_core_field_info", "(", "src", ",", "kind", ")", ";", "if", "(", "result", "!=", "error_mark_node", ")", "maybe_make_core_relo", "(", "src", ",", "kind", ")", ";", "return", "expand_normal", "(", "result", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Expand", "a", "call", "to", "a", "BPF-specific", "built-in", "function", "that", "was", "set", "up", "with", "bpf_init_builtins", "." ]

[ "bpf", "0", "0", "2", "0", "1", "2", "2", "\"invalid argument to built-in function\"", "0", "0", "0", "0", "1", "0", "\"invalid argument to built-in function\"", "0" ]

[]

[ "<s>", "const", "IntegerRangeState", "&", "getState", "(", ")", "const", "override", "{", "return", "*", "this", ";", "}", "</s>" ]

[ "Determine", "the", "state", "of", "the", "lock", "file", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "computeDefaultCPU", "(", "TT", ",", "CPU", ")", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveAArch64CodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "}", "if", "(", "this", "->", "Options", ".", "TLSSize", "==", "0", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "||", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Kernel", ")", "&&", "this", "->", "Options", ".", "TLSSize", ">", "32", ")", "this", "->", "Options", ".", "TLSSize", "=", "32", ";", "else", "if", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", "&&", "this", "->", "Options", ".", "TLSSize", ">", "24", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", "&&", "TT", ".", "getArch", "(", ")", "!=", "Triple", "::", "aarch64_32", "&&", "TT", ".", "getArchName", "(", ")", "!=", "\"arm64e\"", "&&", "TT", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "GNUILP32", "&&", "!", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "{", "setGlobalISel", "(", "true", ")", ";", "setGlobalISelAbort", "(", "GlobalISelAbortMode", "::", "Disable", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "setSupportsDebugEntryValues", "(", "true", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "24", "32", "32", "24", "24", "\"arm64e\"" ]

[]

[ "<s>", "void", "ix86_expand_floorceil", "(", "rtx", "operand0", ",", "rtx", "operand1", ",", "bool", "do_floor", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "xi", ",", "TWO52", ",", "tmp", ",", "one", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "copy_to_reg", "(", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xi", "=", "gen_reg_rtx", "(", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ")", ";", "expand_fix", "(", "xi", ",", "res", ",", "0", ")", ";", "expand_float", "(", "xa", ",", "xi", ",", "0", ")", ";", "one", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "dconst1", ",", "mode", ")", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "xa", ",", "res", ",", "!", "do_floor", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "one", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "do_floor", "?", "MINUS", ":", "PLUS", ",", "xa", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "HONOR_SIGNED_ZEROS", "(", "mode", ")", ")", "{", "if", "(", "do_floor", "&&", "flag_rounding_math", ")", "tmp", "=", "ix86_expand_sse_fabs", "(", "tmp", ",", "NULL", ")", ";", "ix86_sse_copysign_to_positive", "(", "tmp", ",", "tmp", ",", "res", ",", "mask", ")", ";", "}", "emit_move_insn", "(", "res", ",", "tmp", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE2", "sequence", "for", "computing", "floor", "or", "ceil", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

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

[]

[ "<s>", "void", "NyuziFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "Nyuzi", "::", "FP_REG", ")", ";", "if", "(", "isInt", "<", "14", ">", "(", "getWorstCaseStackSize", "(", "MF", ")", ")", ")", "return", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "Nyuzi", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi::FP_REG", "14", "Nyuzi::GPR32RegClass" ]

[]

[ "<s>", "int", "AArch64TTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "Type", "*", "ValTy", ",", "bool", "IsPairwiseForm", ")", "{", "if", "(", "IsPairwiseForm", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "ValTy", ")", ";", "MVT", "MTy", "=", "LT", ".", "second", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "assert", "(", "ISD", "&&", "\"Invalid opcode\"", ")", ";", "static", "const", "CostTblEntry", "CostTblNoPairwise", "[", "]", "{", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v16i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i32", ",", "1", "}", ",", "}", ";", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "CostTblNoPairwise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "AArch64", "AArch64", "\"Invalid opcode\"", "ISD::ADD", "MVT::v8i8", "1", "ISD::ADD", "MVT::v16i8", "1", "ISD::ADD", "MVT::v4i16", "1", "ISD::ADD", "MVT::v8i16", "1", "ISD::ADD", "MVT::v4i32", "1" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "VReg", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "if", "(", "!", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VReg", ")", ";", "}", ")", ")", "return", "false", ";", "FuncReturnHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "8", "X86" ]

[]

[ "<s>", "static", "tree", "aarch64_promoted_type", "(", "const_tree", "t", ")", "{", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "&&", "TYPE_MAIN_VARIANT", "(", "t", ")", "==", "aarch64_fp16_type_node", ")", "return", "float_type_node", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_PROMOTED_TYPE", "to", "promote", "__fp16", "to", "float", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "MipsTargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "!", "Subtarget", ".", "hasMips64", "(", ")", ")", "PM", ".", "add", "(", "createMipsEmitGPRestorePass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "M680x0" ]

[]

[ "<s>", "static", "char", "*", "rs6000_savres_routine_name", "(", "int", "regno", ",", "int", "sel", ")", "{", "const", "char", "*", "prefix", "=", "\"\"", ";", "const", "char", "*", "suffix", "=", "\"\"", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "if", "(", "TARGET_64BIT", ")", "goto", "aix_names", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "\"_savegpr_\"", ":", "\"_restgpr_\"", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "\"_savefpr_\"", ":", "\"_restfpr_\"", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "\"_savevr_\"", ":", "\"_restvr_\"", ";", "else", "abort", "(", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_LR", ")", ")", "suffix", "=", "\"_x\"", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "gcc_assert", "(", "!", "TARGET_AIX", "||", "(", "sel", "&", "SAVRES_REG", ")", "!=", "SAVRES_GPR", ")", ";", "aix_names", ":", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", ")", "prefix", "=", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "\"_savegpr0_\"", ":", "\"_savegpr1_\"", ")", ":", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "\"_restgpr0_\"", ":", "\"_restgpr1_\"", ")", ")", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", ")", "{", "if", "(", "(", "sel", "&", "SAVRES_LR", ")", ")", "prefix", "=", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "\"_savefpr_\"", ":", "\"_restfpr_\"", ")", ";", "else", "{", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "SAVE_FP_PREFIX", ":", "RESTORE_FP_PREFIX", ";", "suffix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "SAVE_FP_SUFFIX", ":", "RESTORE_FP_SUFFIX", ";", "}", "}", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "\"_savevr_\"", ":", "\"_restvr_\"", ";", "else", "abort", "(", ")", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "{", "prefix", "=", "(", "sel", "&", "SAVRES_SAVE", ")", "?", "\"save\"", ":", "\"rest\"", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", ")", "sprintf", "(", "savres_routine_name", ",", "\"*%sGPR%s%s%.0d ; %s r%d-r31\"", ",", "prefix", ",", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "\"x\"", ":", "\"\"", ")", ",", "(", "regno", "==", "13", "?", "\"\"", ":", "\"+\"", ")", ",", "(", "regno", "-", "13", ")", "*", "4", ",", "prefix", ",", "regno", ")", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", ")", "sprintf", "(", "savres_routine_name", ",", "\"*%sFP%s%.0d ; %s f%d-f31\"", ",", "prefix", ",", "(", "regno", "==", "14", "?", "\"\"", ":", "\"+\"", ")", ",", "(", "regno", "-", "14", ")", "*", "4", ",", "prefix", ",", "regno", ")", ";", "else", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "sprintf", "(", "savres_routine_name", ",", "\"*%sVEC%s%.0d ; %s v%d-v31\"", ",", "prefix", ",", "(", "regno", "==", "20", "?", "\"\"", ":", "\"+\"", ")", ",", "(", "regno", "-", "20", ")", "*", "8", ",", "prefix", ",", "regno", ")", ";", "else", "abort", "(", ")", ";", "}", "else", "sprintf", "(", "savres_routine_name", ",", "\"%s%d%s\"", ",", "prefix", ",", "regno", ",", "suffix", ")", ";", "return", "savres_routine_name", ";", "}", "</s>" ]

[ "Return", "the", "name", "for", "an", "out-of-line", "register", "save/restore", "routine", ".", "We", "are", "saving/restoring", "GPRs", "if", "GPR", "is", "true", "." ]

[ "rs6000", "\"\"", "\"\"", "\"_savegpr_\"", "\"_restgpr_\"", "\"_savefpr_\"", "\"_restfpr_\"", "\"_savevr_\"", "\"_restvr_\"", "\"_x\"", "\"_savegpr0_\"", "\"_savegpr1_\"", "\"_restgpr0_\"", "\"_restgpr1_\"", "\"_savefpr_\"", "\"_restfpr_\"", "\"_savevr_\"", "\"_restvr_\"", "\"save\"", "\"rest\"", "\"*%sGPR%s%s%.0d ; %s r%d-r31\"", "\"x\"", "\"\"", "13", "\"\"", "\"+\"", "13", "4", "\"*%sFP%s%.0d ; %s f%d-f31\"", "14", "\"\"", "\"+\"", "14", "4", "\"*%sVEC%s%.0d ; %s v%d-v31\"", "20", "\"\"", "\"+\"", "20", "8", "\"%s%d%s\"" ]

[]

[ "<s>", "static", "void", "s390_swap_cmp", "(", "rtx", "cond", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "tmp", "=", "*", "op0", ";", "if", "(", "cond", "==", "NULL_RTX", ")", "{", "rtx_insn", "*", "jump", "=", "find_cond_jump", "(", "NEXT_INSN", "(", "insn", ")", ")", ";", "rtx", "set", "=", "jump", "?", "single_set", "(", "jump", ")", ":", "NULL_RTX", ";", "if", "(", "set", "==", "NULL_RTX", ")", "return", ";", "cond", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ";", "}", "*", "op0", "=", "*", "op1", ";", "*", "op1", "=", "tmp", ";", "PUT_CODE", "(", "cond", ",", "swap_condition", "(", "GET_CODE", "(", "cond", ")", ")", ")", ";", "}", "</s>" ]

[ "Swap", "the", "condition", "in", "COND", "and", "the", "operands", "in", "OP0", "and", "OP1", "so", "that", "the", "semantics", "does", "not", "change", ".", "If", "NULL_RTX", "is", "passed", "as", "COND", "the", "function", "tries", "to", "find", "the", "conditional", "jump", "starting", "with", "INSN", "." ]

[ "s390", "0" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "LowerFormalArguments_SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "ARM64AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "int64_t", "(", "Value", ")", "!=", "int64_t", "(", "int8_t", "(", "Value", ")", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64" ]

[]

[ "<s>", "char", "*", "crx_prepare_push_pop_string", "(", "int", "push_or_pop", ")", "{", "static", "char", "mask_str", "[", "50", "]", ";", "int", "i", "=", "0", ";", "int", "ra_in_bitmask", "=", "0", ";", "char", "*", "return_str", ";", "char", "*", "temp_str", ";", "return_str", "=", "(", "char", "*", ")", "xmalloc", "(", "120", ")", ";", "temp_str", "=", "(", "char", "*", ")", "xmalloc", "(", "120", ")", ";", "memset", "(", "return_str", ",", "0", ",", "3", ")", ";", "while", "(", "i", "<=", "last_reg_to_save", ")", "{", "mask_str", "[", "0", "]", "=", "0", ";", "if", "(", "i", "<=", "SP_REGNUM", ")", "{", "int", "j", "=", "0", ";", "while", "(", "j", "<", "MAX_COUNT", "&&", "i", "<=", "SP_REGNUM", ")", "{", "if", "(", "save_regs", "[", "i", "]", ")", "{", "if", "(", "i", "==", "RETURN_ADDRESS_REGNUM", ")", "ra_in_bitmask", "=", "1", ";", "if", "(", "j", ">", "0", ")", "strcat", "(", "mask_str", ",", "\", \"", ")", ";", "strcat", "(", "mask_str", ",", "reg_names", "[", "i", "]", ")", ";", "++", "j", ";", "}", "++", "i", ";", "}", "}", "else", "{", "while", "(", "i", "<=", "last_reg_to_save", ")", "{", "if", "(", "save_regs", "[", "i", "]", ")", "{", "strcat", "(", "mask_str", ",", "\"lo, hi\"", ")", ";", "i", "=", "last_reg_to_save", "+", "1", ";", "break", ";", "}", "++", "i", ";", "}", "}", "if", "(", "strlen", "(", "mask_str", ")", "==", "0", ")", "continue", ";", "if", "(", "push_or_pop", "==", "1", ")", "{", "if", "(", "crx_interrupt_function_p", "(", ")", ")", "mpushpop_str", "(", "temp_str", ",", "\"popx\"", ",", "mask_str", ")", ";", "else", "{", "if", "(", "ra_in_bitmask", ")", "{", "mpushpop_str", "(", "temp_str", ",", "\"popret\"", ",", "mask_str", ")", ";", "ra_in_bitmask", "=", "0", ";", "}", "else", "mpushpop_str", "(", "temp_str", ",", "\"pop\"", ",", "mask_str", ")", ";", "}", "strcat", "(", "return_str", ",", "temp_str", ")", ";", "}", "else", "{", "if", "(", "crx_interrupt_function_p", "(", ")", ")", "mpushpop_str", "(", "temp_str", ",", "\"pushx\"", ",", "mask_str", ")", ";", "else", "mpushpop_str", "(", "temp_str", ",", "\"push\"", ",", "mask_str", ")", ";", "strcat", "(", "temp_str", ",", "return_str", ")", ";", "strcpy", "(", "strcat", "(", "return_str", ",", "\"\\t\"", ")", ",", "temp_str", ")", ";", "}", "}", "if", "(", "push_or_pop", "==", "1", ")", "{", "if", "(", "crx_interrupt_function_p", "(", ")", ")", "strcat", "(", "return_str", ",", "\"\\n\\tretx\\n\"", ")", ";", "else", "if", "(", "!", "FUNC_IS_NORETURN_P", "(", "current_function_decl", ")", "&&", "!", "save_regs", "[", "RETURN_ADDRESS_REGNUM", "]", ")", "strcat", "(", "return_str", ",", "\"\\n\\tjump\\tra\\n\"", ")", ";", "}", "return_str", "+=", "2", ";", "return", "return_str", ";", "}", "</s>" ]

[ "Called", "from", "crx.md", ".", "The", "return", "value", "depends", "on", "the", "parameter", "push_or_pop", ":", "*", "When", "push_or_pop", "is", "zero", "-", ">", "string", "for", "push", "instructions", "of", "prologue", ".", "*", "When", "push_or_pop", "is", "nonzero", "-", ">", "string", "for", "pop/popret/retx", "in", "epilogue", ".", "*", "Relies", "on", "the", "assumptions", ":", "*", "1", ".", "RA", "is", "the", "last", "register", "to", "be", "saved", ".", "*", "2", ".", "The", "maximal", "value", "of", "the", "counter", "is", "MAX_COUNT", "." ]

[ "crx", "50", "0", "0", "120", "120", "0", "3", "0", "0", "0", "1", "0", "\", \"", "\"lo, hi\"", "1", "0", "1", "\"popx\"", "\"popret\"", "0", "\"pop\"", "\"pushx\"", "\"push\"", "\"\\t\"", "1", "\"\\n\\tretx\\n\"", "\"\\n\\tjump\\tra\\n\"", "2" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "hasInlineStackProbe", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isOSWindows", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"no-stack-arg-probe\"", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"probe-stack\"", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"probe-stack\"", ")", ".", "getValueAsString", "(", ")", "==", "\"inline-asm\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "stack", "probing", "through", "inline", "assembly", "is", "requested", "." ]

[ "X86", "X86", "\"no-stack-arg-probe\"", "\"probe-stack\"", "\"probe-stack\"", "\"inline-asm\"" ]

[]

[ "<s>", "static", "void", "insert_wic", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "int", "i", ";", "basic_block", "bb", ",", "prev", "=", "0", ";", "rtx", "branch_target", "=", "0", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_basic_blocks_for_fn", "(", "cfun", ")", "-", "1", ";", "i", "++", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "bool", "simple_loop", "=", "false", ";", "bb", "=", "BASIC_BLOCK_FOR_FN", "(", "cfun", ",", "i", ")", ";", "if", "(", "bb", "==", "NULL", ")", "continue", ";", "if", "(", "(", "prev", "!=", "0", ")", "&&", "(", "prev", "!=", "bb", ")", ")", "continue", ";", "else", "prev", "=", "0", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "e", "->", "src", "==", "bb", ")", "{", "simple_loop", "=", "true", ";", "prev", "=", "e", "->", "dest", ";", "break", ";", "}", "for", "(", "insn", "=", "BB_END", "(", "bb", ")", ";", "insn", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", "&&", "!", "simple_loop", "&&", "CALL_P", "(", "insn", ")", ")", "{", "if", "(", "(", "branch_target", "=", "get_branch_target", "(", "insn", ")", ")", ")", "insert_wic_for_ilb_runout", "(", "next_active_insn", "(", "next_active_insn", "(", "insn", ")", ")", ")", ";", "}", "if", "(", "insn", "==", "BB_HEAD", "(", "bb", ")", ")", "break", ";", "}", "}", "}", "</s>" ]

[ "Insert", "instruction", "prefetch", "instruction", "at", "the", "fall", "through", "path", "of", "the", "function", "call", "." ]

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

[]

[ "<s>", "static", "bool", "global_reg_mentioned_p_1", "(", "const_rtx", "x", ")", "{", "int", "regno", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SUBREG", ":", "if", "(", "REG_P", "(", "SUBREG_REG", "(", "x", ")", ")", ")", "{", "if", "(", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "global_regs", "[", "subreg_regno", "(", "x", ")", "]", ")", "return", "true", ";", "return", "false", ";", "}", "break", ";", "case", "REG", ":", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "global_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "false", ";", "case", "CALL", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "global_reg_mentioned_p", ",", "returns", "1", "if", "*", "LOC", "mentions", "a", "global", "register", "." ]

[ "mep" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enablePostRAScheduler", "(", ")", "const", "{", "if", "(", "getSchedModel", "(", ")", ".", "isOutOfOrder", "(", ")", "&&", "isSwift", "(", ")", ")", "return", "false", ";", "return", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "OpenRISC", "OpenRISC", "OpenRISC" ]

[]

[ "<s>", "MachineBasicBlock", "&", "getBlock", "(", ")", "const", "{", "return", "Block", ";", "}", "</s>" ]

[ "getBlock", "-", "Return", "the", "current", "basic", "block", "." ]

[ "Hexagon" ]

[]