<html><head><meta http-equiv="Content-Type" content="text/html charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">Hi Konstantin<span style="font-family: Calibri, Arial, Helvetica, sans-serif; font-size: 12pt;" class="">,</span><div class=""><font face="Calibri, Arial, Helvetica, sans-serif" size="3" class=""><br class=""></font><div><blockquote type="cite" class=""><div class="">On Oct 17, 2016, at 1:04 PM, Konstantin Zhuravlyov <<a href="mailto:kzhuravl_dev@outlook.com" class="">kzhuravl_dev@outlook.com</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><div dir="ltr" style="font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-width: 0px;" class=""><div id="x_divtagdefaultwrapper" style="font-size: 12pt; font-family: Calibri, Arial, Helvetica, sans-serif;" class=""><div style="margin-top: 0px; margin-bottom: 0px;" class="">Hi <span class="">Quentin,</span></div><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class=""><br class=""></span></div><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class="">We do have getOrdering in <span class="">MemSDNode. Since MemSDNode::getOrdering and AtomicSDNode::getSuccessOrdering return the same kind of ordering it was decided to put an assert in getSuccessOrdering to make sure it is only called on cmpxchg operation.</span></span></div><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class=""><span class=""><br class=""></span></span></div><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class=""><span class="">After sleeping on it for a few days, I agree, it does not make much sense to have an assert in getSuccessOrdering. Would it be better to just retire getSuccessOrdering, and switch everything to using getOrdering rather than removing an assert?</span></span></div></div></div></div></blockquote><div><br class=""></div><div>Sounds reasonable to me.</div><div><br class=""></div><div>Cheers,</div><div>-Quentin</div><br class=""><blockquote type="cite" class=""><div class=""><div dir="ltr" style="font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-width: 0px;" class=""><div id="x_divtagdefaultwrapper" style="font-size: 12pt; font-family: Calibri, Arial, Helvetica, sans-serif;" class=""><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class=""><span class=""><br class=""></span></span></div><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class=""><span class="">Thanks,</span></span></div><div style="margin-top: 0px; margin-bottom: 0px;" class=""><span class=""><span class="">Konstantin</span></span></div></div><hr tabindex="-1" style="display: inline-block; width: 616.40625px;" class=""><div id="x_divRplyFwdMsg" dir="ltr" class=""><font face="Calibri, sans-serif" style="font-size: 11pt;" class=""><b class="">From:</b><span class="Apple-converted-space"> </span><a href="mailto:qcolombet@apple.com" class="">qcolombet@apple.com</a> <<a href="mailto:qcolombet@apple.com" class="">qcolombet@apple.com</a>> on behalf of Quentin Colombet <<a href="mailto:qcolombet@apple.com" class="">qcolombet@apple.com</a>><br class=""><b class="">Sent:</b><span class="Apple-converted-space"> </span>Monday, October 17, 2016 1:39:24 PM<br class=""><b class="">To:</b><span class="Apple-converted-space"> </span>Konstantin Zhuravlyov<br class=""><b class="">Cc:</b><span class="Apple-converted-space"> </span><a href="mailto:llvm-commits@lists.llvm.org" class="">llvm-commits@lists.llvm.org</a><br class=""><b class="">Subject:</b><span class="Apple-converted-space"> </span>Re: [llvm] r284312 - [MachineMemOperand] Move synchronization scope and atomic orderings from SDNode to MachineMemOperand, and remove redundant getAtomic* member functions from SelectionDAG.</font><div class=""> </div></div></div><font size="2" style="font-family: Helvetica; font-style: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-width: 0px;" class=""><span style="font-size: 10pt;" class=""><div class="PlainText">Hi Konstantin,<br class=""><br class="">> On Oct 15, 2016, at 3:01 PM, Konstantin Zhuravlyov via llvm-commits <<a href="mailto:llvm-commits@lists.llvm.org" class="">llvm-commits@lists.llvm.org</a>> wrote:<br class="">><span class="Apple-converted-space"> </span><br class="">> Author: kzhuravl<br class="">> Date: Sat Oct 15 17:01:18 2016<br class="">> New Revision: 284312<br class="">><span class="Apple-converted-space"> </span><br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project?rev=284312&view=rev" class="">http://llvm.org/viewvc/llvm-project?rev=284312&view=rev</a><br class="">> Log:<br class="">> [MachineMemOperand] Move synchronization scope and atomic orderings from SDNode to MachineMemOperand, and remove redundant getAtomic* member functions from SelectionDAG.<br class="">><span class="Apple-converted-space"> </span><br class="">> Differential Revision:<span class="Apple-converted-space"> </span><a href="https://reviews.llvm.org/D24577" class="">https://reviews.llvm.org/D24577</a><br class="">><span class="Apple-converted-space"> </span><br class="">> Modified:<br class="">> llvm/trunk/include/llvm/CodeGen/MachineFunction.h<br class="">> llvm/trunk/include/llvm/CodeGen/MachineMemOperand.h<br class="">> llvm/trunk/include/llvm/CodeGen/SelectionDAG.h<br class="">> llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h<br class="">> llvm/trunk/lib/CodeGen/MachineFunction.cpp<br class="">> llvm/trunk/lib/CodeGen/MachineInstr.cpp<br class="">> llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp<br class="">> llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp<br class="">> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp<br class="">> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp<br class="">> llvm/trunk/lib/Target/SystemZ/SystemZISelLowering.cpp<br class="">> llvm/trunk/lib/Target/X86/X86ISelLowering.cpp<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/include/llvm/CodeGen/MachineFunction.h<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineFunction.h?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineFunction.h?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/include/llvm/CodeGen/MachineFunction.h (original)<br class="">> +++ llvm/trunk/include/llvm/CodeGen/MachineFunction.h Sat Oct 15 17:01:18 2016<br class="">> @@ -567,11 +567,13 @@ public:<br class="">> /// getMachineMemOperand - Allocate a new MachineMemOperand.<br class="">> /// MachineMemOperands are owned by the MachineFunction and need not be<br class="">> /// explicitly deallocated.<br class="">> - MachineMemOperand *getMachineMemOperand(MachinePointerInfo PtrInfo,<br class="">> - MachineMemOperand::Flags f,<br class="">> - uint64_t s, unsigned base_alignment,<br class="">> - const AAMDNodes &AAInfo = AAMDNodes(),<br class="">> - const MDNode *Ranges = nullptr);<br class="">> + MachineMemOperand *getMachineMemOperand(<br class="">> + MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,<br class="">> + unsigned base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),<br class="">> + const MDNode *Ranges = nullptr,<br class="">> + SynchronizationScope SynchScope = CrossThread,<br class="">> + AtomicOrdering Ordering = AtomicOrdering::NotAtomic,<br class="">> + AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);<br class="">><span class="Apple-converted-space"> </span><br class="">> /// getMachineMemOperand - Allocate a new MachineMemOperand by copying<br class="">> /// an existing one, adjusting by an offset and using the given size.<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/include/llvm/CodeGen/MachineMemOperand.h<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineMemOperand.h?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineMemOperand.h?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/include/llvm/CodeGen/MachineMemOperand.h (original)<br class="">> +++ llvm/trunk/include/llvm/CodeGen/MachineMemOperand.h Sat Oct 15 17:01:18 2016<br class="">> @@ -19,8 +19,10 @@<br class="">> #include "llvm/ADT/BitmaskEnum.h"<br class="">> #include "llvm/ADT/PointerUnion.h"<br class="">> #include "llvm/CodeGen/PseudoSourceValue.h"<br class="">> +#include "llvm/IR/Instructions.h"<br class="">> #include "llvm/IR/Metadata.h"<br class="">> #include "llvm/IR/Value.h" // PointerLikeTypeTraits<Value*><br class="">> +#include "llvm/Support/AtomicOrdering.h"<br class="">> #include "llvm/Support/DataTypes.h"<br class="">><span class="Apple-converted-space"> </span><br class="">> namespace llvm {<br class="">> @@ -115,20 +117,39 @@ public:<br class="">> };<br class="">><span class="Apple-converted-space"> </span><br class="">> private:<br class="">> + /// Atomic information for this memory operation.<br class="">> + struct MachineAtomicInfo {<br class="">> + /// Synchronization scope for this memory operation.<br class="">> + unsigned SynchScope : 1; // enum SynchronizationScope<br class="">> + /// Atomic ordering requirements for this memory operation. For cmpxchg<br class="">> + /// atomic operations, atomic ordering requirements when store occurs.<br class="">> + unsigned Ordering : 4; // enum AtomicOrdering<br class="">> + /// For cmpxchg atomic operations, atomic ordering requirements when store<br class="">> + /// does not occur.<br class="">> + unsigned FailureOrdering : 4; // enum AtomicOrdering<br class="">> + };<br class="">> +<br class="">> MachinePointerInfo PtrInfo;<br class="">> uint64_t Size;<br class="">> Flags FlagVals;<br class="">> uint16_t BaseAlignLog2; // log_2(base_alignment) + 1<br class="">> + MachineAtomicInfo AtomicInfo;<br class="">> AAMDNodes AAInfo;<br class="">> const MDNode *Ranges;<br class="">><span class="Apple-converted-space"> </span><br class="">> public:<br class="">> /// Construct a MachineMemOperand object with the specified PtrInfo, flags,<br class="">> - /// size, and base alignment.<br class="">> + /// size, and base alignment. For atomic operations the synchronization scope<br class="">> + /// and atomic ordering requirements must also be specified. For cmpxchg<br class="">> + /// atomic operations the atomic ordering requirements when store does not<br class="">> + /// occur must also be specified.<br class="">> MachineMemOperand(MachinePointerInfo PtrInfo, Flags flags, uint64_t s,<br class="">> unsigned base_alignment,<br class="">> const AAMDNodes &AAInfo = AAMDNodes(),<br class="">> - const MDNode *Ranges = nullptr);<br class="">> + const MDNode *Ranges = nullptr,<br class="">> + SynchronizationScope SynchScope = CrossThread,<br class="">> + AtomicOrdering Ordering = AtomicOrdering::NotAtomic,<br class="">> + AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);<br class="">><span class="Apple-converted-space"> </span><br class="">> const MachinePointerInfo &getPointerInfo() const { return PtrInfo; }<br class="">><span class="Apple-converted-space"> </span><br class="">> @@ -176,6 +197,28 @@ public:<br class="">> /// Return the range tag for the memory reference.<br class="">> const MDNode *getRanges() const { return Ranges; }<br class="">><span class="Apple-converted-space"> </span><br class="">> + /// Return the synchronization scope for this memory operation.<br class="">> + SynchronizationScope getSynchScope() const {<br class="">> + return static_cast<SynchronizationScope>(AtomicInfo.SynchScope);<br class="">> + }<br class="">> +<br class="">> + /// Return the atomic ordering requirements for this memory operation.<br class="">> + AtomicOrdering getOrdering() const {<br class="">> + return static_cast<AtomicOrdering>(AtomicInfo.Ordering);<br class="">> + }<br class="">> +<br class="">> + /// For cmpxchg atomic operations, return the atomic ordering requirements<br class="">> + /// when store occurs.<br class="">> + AtomicOrdering getSuccessOrdering() const {<br class="">> + return getOrdering();<br class="">> + }<br class="">> +<br class="">> + /// For cmpxchg atomic operations, return the atomic ordering requirements<br class="">> + /// when store does not occur.<br class="">> + AtomicOrdering getFailureOrdering() const {<br class="">> + return static_cast<AtomicOrdering>(AtomicInfo.FailureOrdering);<br class="">> + }<br class="">> +<br class="">> bool isLoad() const { return FlagVals & MOLoad; }<br class="">> bool isStore() const { return FlagVals & MOStore; }<br class="">> bool isVolatile() const { return FlagVals & MOVolatile; }<br class="">> @@ -183,6 +226,10 @@ public:<br class="">> bool isDereferenceable() const { return FlagVals & MODereferenceable; }<br class="">> bool isInvariant() const { return FlagVals & MOInvariant; }<br class="">><span class="Apple-converted-space"> </span><br class="">> + /// Returns true if this operation has an atomic ordering requirement of<br class="">> + /// unordered or higher, false otherwise.<br class="">> + bool isAtomic() const { return getOrdering() != AtomicOrdering::NotAtomic; }<br class="">> +<br class="">> /// Returns true if this memory operation doesn't have any ordering<br class="">> /// constraints other than normal aliasing. Volatile and atomic memory<br class="">> /// operations can't be reordered.<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/include/llvm/CodeGen/SelectionDAG.h<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAG.h?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAG.h?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/include/llvm/CodeGen/SelectionDAG.h (original)<br class="">> +++ llvm/trunk/include/llvm/CodeGen/SelectionDAG.h Sat Oct 15 17:01:18 2016<br class="">> @@ -856,10 +856,7 @@ public:<br class="">> SynchronizationScope SynchScope);<br class="">> SDValue getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> SDVTList VTs, SDValue Chain, SDValue Ptr,<br class="">> - SDValue Cmp, SDValue Swp, MachineMemOperand *MMO,<br class="">> - AtomicOrdering SuccessOrdering,<br class="">> - AtomicOrdering FailureOrdering,<br class="">> - SynchronizationScope SynchScope);<br class="">> + SDValue Cmp, SDValue Swp, MachineMemOperand *MMO);<br class="">><span class="Apple-converted-space"> </span><br class="">> /// Gets a node for an atomic op, produces result (if relevant)<br class="">> /// and chain and takes 2 operands.<br class="">> @@ -868,26 +865,18 @@ public:<br class="">> unsigned Alignment, AtomicOrdering Ordering,<br class="">> SynchronizationScope SynchScope);<br class="">> SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDValue Chain,<br class="">> - SDValue Ptr, SDValue Val, MachineMemOperand *MMO,<br class="">> - AtomicOrdering Ordering, SynchronizationScope SynchScope);<br class="">> + SDValue Ptr, SDValue Val, MachineMemOperand *MMO);<br class="">><span class="Apple-converted-space"> </span><br class="">> /// Gets a node for an atomic op, produces result and chain and<br class="">> /// takes 1 operand.<br class="">> SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, EVT VT,<br class="">> - SDValue Chain, SDValue Ptr, MachineMemOperand *MMO,<br class="">> - AtomicOrdering Ordering, SynchronizationScope SynchScope);<br class="">> + SDValue Chain, SDValue Ptr, MachineMemOperand *MMO);<br class="">><span class="Apple-converted-space"> </span><br class="">> /// Gets a node for an atomic op, produces result and chain and takes N<br class="">> /// operands.<br class="">> SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> SDVTList VTList, ArrayRef<SDValue> Ops,<br class="">> - MachineMemOperand *MMO, AtomicOrdering SuccessOrdering,<br class="">> - AtomicOrdering FailureOrdering,<br class="">> - SynchronizationScope SynchScope);<br class="">> - SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> - SDVTList VTList, ArrayRef<SDValue> Ops,<br class="">> - MachineMemOperand *MMO, AtomicOrdering Ordering,<br class="">> - SynchronizationScope SynchScope);<br class="">> + MachineMemOperand *MMO);<br class="">><span class="Apple-converted-space"> </span><br class="">> /// Creates a MemIntrinsicNode that may produce a<br class="">> /// result and takes a list of operands. Opcode may be INTRINSIC_VOID,<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h (original)<br class="">> +++ llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h Sat Oct 15 17:01:18 2016<br class="">> @@ -424,10 +424,8 @@ protected:<br class="">> uint16_t IsNonTemporal : 1;<br class="">> uint16_t IsDereferenceable : 1;<br class="">> uint16_t IsInvariant : 1;<br class="">> - uint16_t SynchScope : 1; // enum SynchronizationScope<br class="">> - uint16_t Ordering : 4; // enum AtomicOrdering<br class="">> };<br class="">> - enum { NumMemSDNodeBits = NumSDNodeBits + 9 };<br class="">> + enum { NumMemSDNodeBits = NumSDNodeBits + 4 };<br class="">><span class="Apple-converted-space"> </span><br class="">> class LSBaseSDNodeBitfields {<br class="">> friend class LSBaseSDNode;<br class="">> @@ -1113,13 +1111,6 @@ public:<br class="">> bool isDereferenceable() const { return MemSDNodeBits.IsDereferenceable; }<br class="">> bool isInvariant() const { return MemSDNodeBits.IsInvariant; }<br class="">><span class="Apple-converted-space"> </span><br class="">> - AtomicOrdering getOrdering() const {<br class="">> - return static_cast<AtomicOrdering>(MemSDNodeBits.Ordering);<br class="">> - }<br class="">> - SynchronizationScope getSynchScope() const {<br class="">> - return static_cast<SynchronizationScope>(MemSDNodeBits.SynchScope);<br class="">> - }<br class="">> -<br class="">> // Returns the offset from the location of the access.<br class="">> int64_t getSrcValueOffset() const { return MMO->getOffset(); }<br class="">><span class="Apple-converted-space"> </span><br class="">> @@ -1129,6 +1120,12 @@ public:<br class="">> /// Returns the Ranges that describes the dereference.<br class="">> const MDNode *getRanges() const { return MMO->getRanges(); }<br class="">><span class="Apple-converted-space"> </span><br class="">> + /// Return the synchronization scope for this memory operation.<br class="">> + SynchronizationScope getSynchScope() const { return MMO->getSynchScope(); }<br class="">> +<br class="">> + /// Return the atomic ordering requirements for this memory operation.<br class="">> + AtomicOrdering getOrdering() const { return MMO->getOrdering(); }<br class="">> +<br class="">> /// Return the type of the in-memory value.<br class="">> EVT getMemoryVT() const { return MemoryVT; }<br class="">><span class="Apple-converted-space"> </span><br class="">> @@ -1191,45 +1188,34 @@ public:<br class="">><span class="Apple-converted-space"> </span><br class="">> /// This is an SDNode representing atomic operations.<br class="">> class AtomicSDNode : public MemSDNode {<br class="">> - /// For cmpxchg instructions, the ordering requirements when a store does not<br class="">> - /// occur.<br class="">> - AtomicOrdering FailureOrdering;<br class="">> -<br class="">> - void InitAtomic(AtomicOrdering SuccessOrdering,<br class="">> - AtomicOrdering FailureOrdering,<br class="">> - SynchronizationScope SynchScope) {<br class="">> - MemSDNodeBits.Ordering = static_cast<uint16_t>(SuccessOrdering);<br class="">> - assert(getOrdering() == SuccessOrdering && "Value truncated");<br class="">> - MemSDNodeBits.SynchScope = static_cast<uint16_t>(SynchScope);<br class="">> - assert(getSynchScope() == SynchScope && "Value truncated");<br class="">> - this->FailureOrdering = FailureOrdering;<br class="">> - }<br class="">> -<br class="">> public:<br class="">> AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL,<br class="">> - EVT MemVT, MachineMemOperand *MMO,<br class="">> - AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,<br class="">> - SynchronizationScope SynchScope)<br class="">> - : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {<br class="">> - InitAtomic(SuccessOrdering, FailureOrdering, SynchScope);<br class="">> - }<br class="">> + EVT MemVT, MachineMemOperand *MMO)<br class="">> + : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {}<br class="">><span class="Apple-converted-space"> </span><br class="">> const SDValue &getBasePtr() const { return getOperand(1); }<br class="">> const SDValue &getVal() const { return getOperand(2); }<br class="">><span class="Apple-converted-space"> </span><br class="">> - AtomicOrdering getSuccessOrdering() const {<br class="">> - return getOrdering();<br class="">> + /// Returns true if this SDNode represents cmpxchg atomic operation, false<br class="">> + /// otherwise.<br class="">> + bool isCompareAndSwap() const {<br class="">> + unsigned Op = getOpcode();<br class="">> + return Op == ISD::ATOMIC_CMP_SWAP ||<br class="">> + Op == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS;<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> - // Not quite enough room in SubclassData for everything, so failure gets its<br class="">> - // own field.<br class="">> - AtomicOrdering getFailureOrdering() const {<br class="">> - return FailureOrdering;<br class="">> + /// For cmpxchg atomic operations, return the atomic ordering requirements<br class="">> + /// when store occurs.<br class="">> + AtomicOrdering getSuccessOrdering() const {<br class="">> + assert(isCompareAndSwap() && "Must be cmpxchg operation”);<br class=""><br class="">Correct me if I am wrong, but the assert does not make much to me.<br class="">If we are to take the SuccessOrdering of the MemoryOperand anyway, why should we check for the type of instruction?<br class="">My concern is that we end up with an API for this type of node that does not work for all the nodes that fall in that class.<br class=""><br class="">What do you think?<br class=""><br class="">Cheers,<br class="">-Quentin<br class=""><br class="">> + return MMO->getSuccessOrdering();<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> - bool isCompareAndSwap() const {<br class="">> - unsigned Op = getOpcode();<br class="">> - return Op == ISD::ATOMIC_CMP_SWAP || Op == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS;<br class="">> + /// For cmpxchg atomic operations, return the atomic ordering requirements<br class="">> + /// when store does not occur.<br class="">> + AtomicOrdering getFailureOrdering() const {<br class="">> + assert(isCompareAndSwap() && "Must be cmpxchg operation");<br class="">> + return MMO->getFailureOrdering();<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> // Methods to support isa and dyn_cast<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/CodeGen/MachineFunction.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineFunction.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineFunction.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/CodeGen/MachineFunction.cpp (original)<br class="">> +++ llvm/trunk/lib/CodeGen/MachineFunction.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -306,9 +306,12 @@ MachineFunction::DeleteMachineBasicBlock<br class="">><span class="Apple-converted-space"> </span><br class="">> MachineMemOperand *MachineFunction::getMachineMemOperand(<br class="">> MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,<br class="">> - unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges) {<br class="">> + unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,<br class="">> + SynchronizationScope SynchScope, AtomicOrdering Ordering,<br class="">> + AtomicOrdering FailureOrdering) {<br class="">> return new (Allocator)<br class="">> - MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges);<br class="">> + MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,<br class="">> + SynchScope, Ordering, FailureOrdering);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> MachineMemOperand *<br class="">> @@ -318,13 +321,15 @@ MachineFunction::getMachineMemOperand(co<br class="">> return new (Allocator)<br class="">> MachineMemOperand(MachinePointerInfo(MMO->getValue(),<br class="">> MMO->getOffset()+Offset),<br class="">> - MMO->getFlags(), Size,<br class="">> - MMO->getBaseAlignment());<br class="">> + MMO->getFlags(), Size, MMO->getBaseAlignment(),<br class="">> + AAMDNodes(), nullptr, MMO->getSynchScope(),<br class="">> + MMO->getOrdering(), MMO->getFailureOrdering());<br class="">> return new (Allocator)<br class="">> MachineMemOperand(MachinePointerInfo(MMO->getPseudoValue(),<br class="">> MMO->getOffset()+Offset),<br class="">> - MMO->getFlags(), Size,<br class="">> - MMO->getBaseAlignment());<br class="">> + MMO->getFlags(), Size, MMO->getBaseAlignment(),<br class="">> + AAMDNodes(), nullptr, MMO->getSynchScope(),<br class="">> + MMO->getOrdering(), MMO->getFailureOrdering());<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> MachineInstr::mmo_iterator<br class="">> @@ -355,7 +360,9 @@ MachineFunction::extractLoadMemRefs(Mach<br class="">> getMachineMemOperand((*I)->getPointerInfo(),<br class="">> (*I)->getFlags() & ~MachineMemOperand::MOStore,<br class="">> (*I)->getSize(), (*I)->getBaseAlignment(),<br class="">> - (*I)->getAAInfo());<br class="">> + (*I)->getAAInfo(), nullptr,<br class="">> + (*I)->getSynchScope(), (*I)->getOrdering(),<br class="">> + (*I)->getFailureOrdering());<br class="">> Result[Index] = JustLoad;<br class="">> }<br class="">> ++Index;<br class="">> @@ -387,7 +394,9 @@ MachineFunction::extractStoreMemRefs(Mac<br class="">> getMachineMemOperand((*I)->getPointerInfo(),<br class="">> (*I)->getFlags() & ~MachineMemOperand::MOLoad,<br class="">> (*I)->getSize(), (*I)->getBaseAlignment(),<br class="">> - (*I)->getAAInfo());<br class="">> + (*I)->getAAInfo(), nullptr,<br class="">> + (*I)->getSynchScope(), (*I)->getOrdering(),<br class="">> + (*I)->getFailureOrdering());<br class="">> Result[Index] = JustStore;<br class="">> }<br class="">> ++Index;<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/CodeGen/MachineInstr.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineInstr.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineInstr.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/CodeGen/MachineInstr.cpp (original)<br class="">> +++ llvm/trunk/lib/CodeGen/MachineInstr.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -537,7 +537,10 @@ MachinePointerInfo MachinePointerInfo::g<br class="">> MachineMemOperand::MachineMemOperand(MachinePointerInfo ptrinfo, Flags f,<br class="">> uint64_t s, unsigned int a,<br class="">> const AAMDNodes &AAInfo,<br class="">> - const MDNode *Ranges)<br class="">> + const MDNode *Ranges,<br class="">> + SynchronizationScope SynchScope,<br class="">> + AtomicOrdering Ordering,<br class="">> + AtomicOrdering FailureOrdering)<br class="">> : PtrInfo(ptrinfo), Size(s), FlagVals(f), BaseAlignLog2(Log2_32(a) + 1),<br class="">> AAInfo(AAInfo), Ranges(Ranges) {<br class="">> assert((PtrInfo.V.isNull() || <a href="http://PtrInfo.V.is" class="">PtrInfo.V.is</a><const PseudoSourceValue*>() ||<br class="">> @@ -545,6 +548,13 @@ MachineMemOperand::MachineMemOperand(Mac<br class="">> "invalid pointer value");<br class="">> assert(getBaseAlignment() == a && "Alignment is not a power of 2!");<br class="">> assert((isLoad() || isStore()) && "Not a load/store!");<br class="">> +<br class="">> + AtomicInfo.SynchScope = static_cast<unsigned>(SynchScope);<br class="">> + assert(getSynchScope() == SynchScope && "Value truncated");<br class="">> + AtomicInfo.Ordering = static_cast<unsigned>(Ordering);<br class="">> + assert(getOrdering() == Ordering && "Value truncated");<br class="">> + AtomicInfo.FailureOrdering = static_cast<unsigned>(FailureOrdering);<br class="">> + assert(getFailureOrdering() == FailureOrdering && "Value truncated");<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> /// Profile - Gather unique data for the object.<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp (original)<br class="">> +++ llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -2835,10 +2835,7 @@ bool SelectionDAGLegalize::ExpandNode(SD<br class="">> SDValue Swap = DAG.getAtomicCmpSwap(<br class="">> ISD::ATOMIC_CMP_SWAP, dl, cast<AtomicSDNode>(Node)->getMemoryVT(), VTs,<br class="">> Node->getOperand(0), Node->getOperand(1), Zero, Zero,<br class="">> - cast<AtomicSDNode>(Node)->getMemOperand(),<br class="">> - cast<AtomicSDNode>(Node)->getOrdering(),<br class="">> - cast<AtomicSDNode>(Node)->getOrdering(),<br class="">> - cast<AtomicSDNode>(Node)->getSynchScope());<br class="">> + cast<AtomicSDNode>(Node)->getMemOperand());<br class="">> Results.push_back(Swap.getValue(0));<br class="">> Results.push_back(Swap.getValue(1));<br class="">> break;<br class="">> @@ -2849,9 +2846,7 @@ bool SelectionDAGLegalize::ExpandNode(SD<br class="">> cast<AtomicSDNode>(Node)->getMemoryVT(),<br class="">> Node->getOperand(0),<br class="">> Node->getOperand(1), Node->getOperand(2),<br class="">> - cast<AtomicSDNode>(Node)->getMemOperand(),<br class="">> - cast<AtomicSDNode>(Node)->getOrdering(),<br class="">> - cast<AtomicSDNode>(Node)->getSynchScope());<br class="">> + cast<AtomicSDNode>(Node)->getMemOperand());<br class="">> Results.push_back(Swap.getValue(1));<br class="">> break;<br class="">> }<br class="">> @@ -2863,10 +2858,7 @@ bool SelectionDAGLegalize::ExpandNode(SD<br class="">> SDValue Res = DAG.getAtomicCmpSwap(<br class="">> ISD::ATOMIC_CMP_SWAP, dl, cast<AtomicSDNode>(Node)->getMemoryVT(), VTs,<br class="">> Node->getOperand(0), Node->getOperand(1), Node->getOperand(2),<br class="">> - Node->getOperand(3), cast<MemSDNode>(Node)->getMemOperand(),<br class="">> - cast<AtomicSDNode>(Node)->getSuccessOrdering(),<br class="">> - cast<AtomicSDNode>(Node)->getFailureOrdering(),<br class="">> - cast<AtomicSDNode>(Node)->getSynchScope());<br class="">> + Node->getOperand(3), cast<MemSDNode>(Node)->getMemOperand());<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue ExtRes = Res;<br class="">> SDValue LHS = Res;<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp (original)<br class="">> +++ llvm/trunk/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -188,8 +188,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_<br class="">> SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),<br class="">> N->getMemoryVT(), ResVT,<br class="">> N->getChain(), N->getBasePtr(),<br class="">> - N->getMemOperand(), N->getOrdering(),<br class="">> - N->getSynchScope());<br class="">> + N->getMemOperand());<br class="">> // Legalize the chain result - switch anything that used the old chain to<br class="">> // use the new one.<br class="">> ReplaceValueWith(SDValue(N, 1), Res.getValue(1));<br class="">> @@ -201,8 +200,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_<br class="">> SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),<br class="">> N->getMemoryVT(),<br class="">> N->getChain(), N->getBasePtr(),<br class="">> - Op2, N->getMemOperand(), N->getOrdering(),<br class="">> - N->getSynchScope());<br class="">> + Op2, N->getMemOperand());<br class="">> // Legalize the chain result - switch anything that used the old chain to<br class="">> // use the new one.<br class="">> ReplaceValueWith(SDValue(N, 1), Res.getValue(1));<br class="">> @@ -225,8 +223,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_<br class="">> SDValue Res = DAG.getAtomicCmpSwap(<br class="">> ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, SDLoc(N), N->getMemoryVT(), VTs,<br class="">> N->getChain(), N->getBasePtr(), N->getOperand(2), N->getOperand(3),<br class="">> - N->getMemOperand(), N->getSuccessOrdering(), N->getFailureOrdering(),<br class="">> - N->getSynchScope());<br class="">> + N->getMemOperand());<br class="">> ReplaceValueWith(SDValue(N, 0), Res.getValue(0));<br class="">> ReplaceValueWith(SDValue(N, 2), Res.getValue(2));<br class="">> return Res.getValue(1);<br class="">> @@ -238,8 +235,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_<br class="">> DAG.getVTList(Op2.getValueType(), N->getValueType(1), MVT::Other);<br class="">> SDValue Res = DAG.getAtomicCmpSwap(<br class="">> N->getOpcode(), SDLoc(N), N->getMemoryVT(), VTs, N->getChain(),<br class="">> - N->getBasePtr(), Op2, Op3, N->getMemOperand(), N->getSuccessOrdering(),<br class="">> - N->getFailureOrdering(), N->getSynchScope());<br class="">> + N->getBasePtr(), Op2, Op3, N->getMemOperand());<br class="">> // Update the use to N with the newly created Res.<br class="">> for (unsigned i = 1, NumResults = N->getNumValues(); i < NumResults; ++i)<br class="">> ReplaceValueWith(SDValue(N, i), Res.getValue(i));<br class="">> @@ -997,8 +993,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_A<br class="">> SDValue DAGTypeLegalizer::PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N) {<br class="">> SDValue Op2 = GetPromotedInteger(N->getOperand(2));<br class="">> return DAG.getAtomic(N->getOpcode(), SDLoc(N), N->getMemoryVT(),<br class="">> - N->getChain(), N->getBasePtr(), Op2, N->getMemOperand(),<br class="">> - N->getOrdering(), N->getSynchScope());<br class="">> + N->getChain(), N->getBasePtr(), Op2, N->getMemOperand());<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue DAGTypeLegalizer::PromoteIntOp_BITCAST(SDNode *N) {<br class="">> @@ -1368,8 +1363,7 @@ void DAGTypeLegalizer::ExpandIntegerResu<br class="">> SDValue Tmp = DAG.getAtomicCmpSwap(<br class="">> ISD::ATOMIC_CMP_SWAP, SDLoc(N), AN->getMemoryVT(), VTs,<br class="">> N->getOperand(0), N->getOperand(1), N->getOperand(2), N->getOperand(3),<br class="">> - AN->getMemOperand(), AN->getSuccessOrdering(), AN->getFailureOrdering(),<br class="">> - AN->getSynchScope());<br class="">> + AN->getMemOperand());<br class="">><span class="Apple-converted-space"> </span><br class="">> // Expanding to the strong ATOMIC_CMP_SWAP node means we can determine<br class="">> // success simply by comparing the loaded value against the ingoing<br class="">> @@ -2733,10 +2727,7 @@ void DAGTypeLegalizer::ExpandIntRes_ATOM<br class="">> SDValue Swap = DAG.getAtomicCmpSwap(<br class="">> ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, dl,<br class="">> cast<AtomicSDNode>(N)->getMemoryVT(), VTs, N->getOperand(0),<br class="">> - N->getOperand(1), Zero, Zero, cast<AtomicSDNode>(N)->getMemOperand(),<br class="">> - cast<AtomicSDNode>(N)->getOrdering(),<br class="">> - cast<AtomicSDNode>(N)->getOrdering(),<br class="">> - cast<AtomicSDNode>(N)->getSynchScope());<br class="">> + N->getOperand(1), Zero, Zero, cast<AtomicSDNode>(N)->getMemOperand());<br class="">><span class="Apple-converted-space"> </span><br class="">> ReplaceValueWith(SDValue(N, 0), Swap.getValue(0));<br class="">> ReplaceValueWith(SDValue(N, 1), Swap.getValue(2));<br class="">> @@ -3224,9 +3215,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_AT<br class="">> cast<AtomicSDNode>(N)->getMemoryVT(),<br class="">> N->getOperand(0),<br class="">> N->getOperand(1), N->getOperand(2),<br class="">> - cast<AtomicSDNode>(N)->getMemOperand(),<br class="">> - cast<AtomicSDNode>(N)->getOrdering(),<br class="">> - cast<AtomicSDNode>(N)->getSynchScope());<br class="">> + cast<AtomicSDNode>(N)->getMemOperand());<br class="">> return Swap.getValue(1);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (original)<br class="">> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -4831,10 +4831,7 @@ SDValue SelectionDAG::getMemset(SDValue<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> SDVTList VTList, ArrayRef<SDValue> Ops,<br class="">> - MachineMemOperand *MMO,<br class="">> - AtomicOrdering SuccessOrdering,<br class="">> - AtomicOrdering FailureOrdering,<br class="">> - SynchronizationScope SynchScope) {<br class="">> + MachineMemOperand *MMO) {<br class="">> FoldingSetNodeID ID;<br class="">> ID.AddInteger(MemVT.getRawBits());<br class="">> AddNodeIDNode(ID, Opcode, VTList, Ops);<br class="">> @@ -4846,8 +4843,7 @@ SDValue SelectionDAG::getAtomic(unsigned<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> auto *N = newSDNode<AtomicSDNode>(Opcode, dl.getIROrder(), dl.getDebugLoc(),<br class="">> - VTList, MemVT, MMO, SuccessOrdering,<br class="">> - FailureOrdering, SynchScope);<br class="">> + VTList, MemVT, MMO);<br class="">> createOperands(N, Ops);<br class="">><span class="Apple-converted-space"> </span><br class="">> CSEMap.InsertNode(N, IP);<br class="">> @@ -4855,14 +4851,6 @@ SDValue SelectionDAG::getAtomic(unsigned<br class="">> return SDValue(N, 0);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> -SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> - SDVTList VTList, ArrayRef<SDValue> Ops,<br class="">> - MachineMemOperand *MMO, AtomicOrdering Ordering,<br class="">> - SynchronizationScope SynchScope) {<br class="">> - return getAtomic(Opcode, dl, MemVT, VTList, Ops, MMO, Ordering,<br class="">> - Ordering, SynchScope);<br class="">> -}<br class="">> -<br class="">> SDValue SelectionDAG::getAtomicCmpSwap(<br class="">> unsigned Opcode, const SDLoc &dl, EVT MemVT, SDVTList VTs, SDValue Chain,<br class="">> SDValue Ptr, SDValue Cmp, SDValue Swp, MachinePointerInfo PtrInfo,<br class="">> @@ -4882,26 +4870,23 @@ SDValue SelectionDAG::getAtomicCmpSwap(<br class="">> auto Flags = MachineMemOperand::MOVolatile | MachineMemOperand::MOLoad |<br class="">> MachineMemOperand::MOStore;<br class="">> MachineMemOperand *MMO =<br class="">> - MF.getMachineMemOperand(PtrInfo, Flags, MemVT.getStoreSize(), Alignment);<br class="">> + MF.getMachineMemOperand(PtrInfo, Flags, MemVT.getStoreSize(), Alignment,<br class="">> + AAMDNodes(), nullptr, SynchScope, SuccessOrdering,<br class="">> + FailureOrdering);<br class="">><span class="Apple-converted-space"> </span><br class="">> - return getAtomicCmpSwap(Opcode, dl, MemVT, VTs, Chain, Ptr, Cmp, Swp, MMO,<br class="">> - SuccessOrdering, FailureOrdering, SynchScope);<br class="">> + return getAtomicCmpSwap(Opcode, dl, MemVT, VTs, Chain, Ptr, Cmp, Swp, MMO);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue SelectionDAG::getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl,<br class="">> EVT MemVT, SDVTList VTs, SDValue Chain,<br class="">> SDValue Ptr, SDValue Cmp, SDValue Swp,<br class="">> - MachineMemOperand *MMO,<br class="">> - AtomicOrdering SuccessOrdering,<br class="">> - AtomicOrdering FailureOrdering,<br class="">> - SynchronizationScope SynchScope) {<br class="">> + MachineMemOperand *MMO) {<br class="">> assert(Opcode == ISD::ATOMIC_CMP_SWAP ||<br class="">> Opcode == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS);<br class="">> assert(Cmp.getValueType() == Swp.getValueType() && "Invalid Atomic Op Types");<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue Ops[] = {Chain, Ptr, Cmp, Swp};<br class="">> - return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO,<br class="">> - SuccessOrdering, FailureOrdering, SynchScope);<br class="">> + return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> @@ -4927,16 +4912,15 @@ SDValue SelectionDAG::getAtomic(unsigned<br class="">><span class="Apple-converted-space"> </span><br class="">> MachineMemOperand *MMO =<br class="">> MF.getMachineMemOperand(MachinePointerInfo(PtrVal), Flags,<br class="">> - MemVT.getStoreSize(), Alignment);<br class="">> + MemVT.getStoreSize(), Alignment, AAMDNodes(),<br class="">> + nullptr, SynchScope, Ordering);<br class="">><span class="Apple-converted-space"> </span><br class="">> - return getAtomic(Opcode, dl, MemVT, Chain, Ptr, Val, MMO,<br class="">> - Ordering, SynchScope);<br class="">> + return getAtomic(Opcode, dl, MemVT, Chain, Ptr, Val, MMO);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> SDValue Chain, SDValue Ptr, SDValue Val,<br class="">> - MachineMemOperand *MMO, AtomicOrdering Ordering,<br class="">> - SynchronizationScope SynchScope) {<br class="">> + MachineMemOperand *MMO) {<br class="">> assert((Opcode == ISD::ATOMIC_LOAD_ADD ||<br class="">> Opcode == ISD::ATOMIC_LOAD_SUB ||<br class="">> Opcode == ISD::ATOMIC_LOAD_AND ||<br class="">> @@ -4956,18 +4940,17 @@ SDValue SelectionDAG::getAtomic(unsigned<br class="">> SDVTList VTs = Opcode == ISD::ATOMIC_STORE ? getVTList(MVT::Other) :<br class="">> getVTList(VT, MVT::Other);<br class="">> SDValue Ops[] = {Chain, Ptr, Val};<br class="">> - return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO, Ordering, SynchScope);<br class="">> + return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,<br class="">> EVT VT, SDValue Chain, SDValue Ptr,<br class="">> - MachineMemOperand *MMO, AtomicOrdering Ordering,<br class="">> - SynchronizationScope SynchScope) {<br class="">> + MachineMemOperand *MMO) {<br class="">> assert(Opcode == ISD::ATOMIC_LOAD && "Invalid Atomic Op");<br class="">><span class="Apple-converted-space"> </span><br class="">> SDVTList VTs = getVTList(VT, MVT::Other);<br class="">> SDValue Ops[] = {Chain, Ptr};<br class="">> - return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO, Ordering, SynchScope);<br class="">> + return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);<br class="">> }<br class="">><span class="Apple-converted-space"> </span><br class="">> /// getMergeValues - Create a MERGE_VALUES node from the given operands.<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp (original)<br class="">> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -3973,13 +3973,13 @@ void SelectionDAGBuilder::visitAtomicLoa<br class="">> MachineMemOperand::MOLoad,<br class="">> VT.getStoreSize(),<br class="">> I.getAlignment() ? I.getAlignment() :<br class="">> - DAG.getEVTAlignment(VT));<br class="">> + DAG.getEVTAlignment(VT),<br class="">> + AAMDNodes(), nullptr, Scope, Order);<br class="">><span class="Apple-converted-space"> </span><br class="">> InChain = TLI.prepareVolatileOrAtomicLoad(InChain, dl, DAG);<br class="">> SDValue L =<br class="">> DAG.getAtomic(ISD::ATOMIC_LOAD, dl, VT, VT, InChain,<br class="">> - getValue(I.getPointerOperand()), MMO,<br class="">> - Order, Scope);<br class="">> + getValue(I.getPointerOperand()), MMO);<br class="">><span class="Apple-converted-space"> </span><br class="">> SDValue OutChain = L.getValue(1);<br class="">><span class="Apple-converted-space"> </span><br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/Target/SystemZ/SystemZISelLowering.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/SystemZ/SystemZISelLowering.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/SystemZ/SystemZISelLowering.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/Target/SystemZ/SystemZISelLowering.cpp (original)<br class="">> +++ llvm/trunk/lib/Target/SystemZ/SystemZISelLowering.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -3310,8 +3310,7 @@ SDValue SystemZTargetLowering::lowerATOM<br class="">> if (NegSrc2.getNode())<br class="">> return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, DL, MemVT,<br class="">> Node->getChain(), Node->getBasePtr(), NegSrc2,<br class="">> - Node->getMemOperand(), Node->getOrdering(),<br class="">> - Node->getSynchScope());<br class="">> + Node->getMemOperand());<br class="">><span class="Apple-converted-space"> </span><br class="">> // Use the node as-is.<br class="">> return Op;<br class="">><span class="Apple-converted-space"> </span><br class="">> Modified: llvm/trunk/lib/Target/X86/X86ISelLowering.cpp<br class="">> URL:<span class="Apple-converted-space"> </span><a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86ISelLowering.cpp?rev=284312&r1=284311&r2=284312&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86ISelLowering.cpp?rev=284312&r1=284311&r2=284312&view=diff</a><br class="">> ==============================================================================<br class="">> --- llvm/trunk/lib/Target/X86/X86ISelLowering.cpp (original)<br class="">> +++ llvm/trunk/lib/Target/X86/X86ISelLowering.cpp Sat Oct 15 17:01:18 2016<br class="">> @@ -21597,8 +21597,7 @@ static SDValue lowerAtomicArith(SDValue<br class="">> AtomicSDNode *AN = cast<AtomicSDNode>(N.getNode());<br class="">> RHS = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), RHS);<br class="">> return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, DL, VT, Chain, LHS,<br class="">> - RHS, AN->getMemOperand(), AN->getOrdering(),<br class="">> - AN->getSynchScope());<br class="">> + RHS, AN->getMemOperand());<br class="">> }<br class="">> assert(Opc == ISD::ATOMIC_LOAD_ADD &&<br class="">> "Used AtomicRMW ops other than Add should have been expanded!");<br class="">> @@ -21629,9 +21628,7 @@ static SDValue LowerATOMIC_STORE(SDValue<br class="">> cast<AtomicSDNode>(Node)->getMemoryVT(),<br class="">> Node->getOperand(0),<br class="">> Node->getOperand(1), Node->getOperand(2),<br class="">> - cast<AtomicSDNode>(Node)->getMemOperand(),<br class="">> - cast<AtomicSDNode>(Node)->getOrdering(),<br class="">> - cast<AtomicSDNode>(Node)->getSynchScope());<br class="">> + cast<AtomicSDNode>(Node)->getMemOperand());<br class="">> return Swap.getValue(1);<br class="">> }<br class="">> // Other atomic stores have a simple pattern.<br class="">><span class="Apple-converted-space"> </span><br class="">><span class="Apple-converted-space"> </span><br class="">> _______________________________________________<br class="">> llvm-commits mailing list<br class="">> <a href="mailto:llvm-commits@lists.llvm.org" class="">llvm-commits@lists.llvm.org</a><br class="">><span class="Apple-converted-space"> </span><a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits" class="">http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits</a></div></span></font></div></blockquote></div><br class=""></div></body></html>