public void EmitMOV(Register regDst, int imm32)
{
AddrMode rexAddrMode = new AddrMode(regDst, null, 0, 0, AddrModeSize.Int32);
EmitRexPrefix(regDst, ref rexAddrMode);
Builder.EmitByte((byte)(0xB8 | ((int)regDst & 0x07)));
Builder.EmitInt(imm32);
}
private void updateRegisterState(TextBox txt, Register register)
{
txt.Invoke((MethodInvoker)(() =>
{
txt.Text = _vm.cpu.Registers[register].ToString();
}));
}
/// <summary>
/// Pushes the current value of our programmCounter to the operationStack and sets programmCounter to INTERRUPT_VECTOR_ADDRESS
/// </summary>
public void triggerInterrupt(Data.OperationStack operationStack, Register.ProgramCounter programCounter)
{
operationStack.push(programCounter.value);
programCounter.value = Register.RegisterConstants.INTERRUPT_VECTOR_ADDRESS;
registerFileMap.clearBit(Register.RegisterConstants.INTCON_ADDRESS, Register.RegisterConstants.INTCON_GIE_MASK);
pic.setInterruptIsNext(false);
}
public void ValueBackingTest1()
{
var backing = new MockRegisterValueBacking();
var reg = new Register(RegisterName.Unnamed, backing);
reg.RegisterValue = RegisterValue.OfString("foo", OperationKind.CharacterWise);
Assert.AreEqual("foo", backing.RegisterValue.StringValue);
}
private void RegisterBtn_Click(object sender, RoutedEventArgs e)
{
clearErrorText();
if (validateFields())
{
if (PasswordTxt.Password.Equals(ConfirmPasswordTxt.Password))
{
Register regis = new Register() { username = UsernameTxt.Text, cardNumber = CardNumberTxt.Text, isPublic = (PublicSwitch.IsOn + "").ToLower(), name = NameTxt.Text, password = PasswordTxt.Password, phoneNumber = PhoneTxt.Text };
RequestHandle handler = new RequestHandle();
LoginResponse res = Task.Run(() => handler.register(regis)).Result;
switch (res.user.responseStatus.status)
{
case "INVALID_REGISTRATION_USERNAME":
UsernameErrorTxt.Text = "Username is already in use.";
break;
case "INVALID_REGISTRATION_CARDNUMBER":
CardNumberErrorTxt.Text = "Card number is invalid or in use.";
break;
case "INVALID_REGISTRATION_PHONE":
PhoneErrorTxt.Text = "Phone is already in use.";
break;
case "SUCCESS":
this.Frame.Navigate(typeof(DashboardPage), res.user);
break;
}
}
else
{
PasswordErrorTxt.Text = "Passwords entered do not match.";
}
}
}
public static void AddModuloQFTPhi(this QuantumComputer comp, ulong a, ulong N, RegisterRef ctrl, Register b, params RegisterRef[] controls)
{
if (comp.Group)
{
object[] parameters = new object[] { comp, a, N, ctrl, b, controls };
comp.AddParametricGate("AddModuloQFTPhi", parameters);
return;
}
else
{
comp.Group = true;
}
comp.AddQFTPhi(a, b, controls);
comp.InverseAddQFTPhi(N, b);
comp.InverseQFT(b);
comp.CNot(ctrl, b[b.Width - 1]);
comp.QFT(b);
comp.AddQFTPhi(N, b, ctrl);
comp.InverseAddQFTPhi(a, b, controls);
comp.InverseQFT(b);
comp.SigmaX(b[b.Width - 1]);
comp.CNot(ctrl, b[b.Width - 1]);
comp.SigmaX(b[b.Width - 1]);
comp.QFT(b);
comp.AddQFTPhi(a, b, controls);
}
public void Test_Registered()
{
Register r = new Register(doc);
r.Registered = true;
Assert.AreEqual("<query xmlns=\"jabber:iq:register\"><registered /></query>", r.ToString());
Assert.IsTrue(r.Registered);
}
public void RegisterTaskPanes(Register register)
{
myAddinTaskPane = register(() =>
{
var button = new System.Windows.Controls.Button
{
Content = "Insert Quote"
};
button.Click += InsertQuote;
var host = new WpfPanelHost
{
Child = new UserControl
{
Content = new StackPanel
{
Children =
{
button
}
}
}
};
return host;
}, "Quotes!");
myAddinTaskPane.Visible = true;
myAddinTaskPane.VisibleChanged += TaskPaneVisibleChanged;
TaskPaneVisibleChanged(this, EventArgs.Empty);
}
public TargetRegisterMap(TargetOS os)
{
switch (os)
{
case TargetOS.Windows:
Arg0 = Register.RCX;
Arg1 = Register.RDX;
Arg2 = Register.R8;
Arg3 = Register.R9;
Result = Register.RAX;
break;
case TargetOS.Linux:
case TargetOS.OSX:
case TargetOS.FreeBSD:
Arg0 = Register.RDI;
Arg1 = Register.RSI;
Arg2 = Register.RDX;
Arg3 = Register.RCX;
Result = Register.RAX;
break;
default:
throw new NotImplementedException();
}
}
public void CanSetTheValueOfARegister()
{
var register = new Register(8);
const int expectedValue = 42;
register.SetValue(expectedValue);
Assert.That(register.GetValue(), Is.EqualTo(expectedValue));
}
public LWCInstruction(int copid,Register rs,int coprd,int imm)
{
this.copid = copid;
this.rs = rs;
this.coprd = coprd;
this.imm = imm;
}
private void cmdRegister_Click(object sender, EventArgs e)
{
Register reg = new Register();
reg.UserName = txtName.Text;
reg.EMail = txtEMail.Text;
mChannel.Send(reg);
}
public void ValueBackingTest2()
{
var backing = new MockRegisterValueBacking();
var reg = new Register(RegisterName.Unnamed, backing);
backing.Value = new RegisterValue(StringData.NewSimple("foo"), OperationKind.CharacterWise);
Assert.AreEqual("foo", reg.StringValue);
}
public static void InverseAddModuloQFT(this QuantumComputer comp, ulong a, ulong N, RegisterRef ctrl, Register b, params RegisterRef[] controls)
{
Validate(a, b, N);
comp.QFT(b);
comp.InverseAddModuloQFTPhi(a, N, ctrl, b, controls);
comp.InverseQFT(b);
}
/// <summary>
/// Crates a new EEPROM Handler to enable EEPROM functionality.
/// IMPORTANT: call dispose(); when it's no longer needed.
/// </summary>
/// <param name="_registerFileMap"></param>
/// <param name="_eepromMemory"></param>
public EEPROMHandler(Register.RegisterFileMap _registerFileMap, Data.EEPROMMemory _eepromMemory)
{
this.registerFileMap = _registerFileMap;
this.eepromMemory = _eepromMemory;
this.valueChangeListener = new Data.DataAdapter<byte>.OnDataChanged(onValueChange);
registerSelfWithRegisterFileMap();
}
public void RegisterSelf(Register register)
{
contentTaskPane = register(() => new WpfPanelHost
{
Child = this
}, "GitHub for Outlook", false);
}
public static void Reverse(this QuantumComputer comp, Register a)
{
for (int i = 0; i < a.Width / 2; i++)
{
comp.Swap(a[i], a[a.Width - 1 - i]);
}
}
public static void AddQFT(this QuantumComputer comp, ulong a, Register b, params RegisterRef[] controls)
{
Validate(a, b);
comp.QFT(b);
comp.AddQFTPhi(a, b, controls);
comp.InverseQFT(b);
}
public BitOperation(short _targetAddress, short _bitNumber, BitOperator _op, Register.RegisterFileMap _registerFileMap, short _address)
: base(_registerFileMap, CYCLES, _address)
{
this.targetAddress = _targetAddress;
this.bitNumber = _bitNumber;
this.op = _op;
}
private static void Validate(Register target, ulong number)
{
if ((number >> target.Width) > 0)
{
throw new System.ArgumentException("Target register is too small. It must have enough space to store loaded number.");
}
}
public void EmitMOV(Register regDst, Register regSrc)
{
AddrMode rexAddrMode = new AddrMode(regSrc, null, 0, 0, AddrModeSize.Int64);
EmitRexPrefix(regDst, ref rexAddrMode);
Builder.EmitByte(0x89);
Builder.EmitByte((byte)(0xC0 | (((int)regSrc & 0x07) << 3) | (((int)regDst & 0x07))));
}
/// <summary>
/// Default ctor
/// </summary>
public VariableStartEntry(int offset, Register register, IVariable variable, TypeReference type) : base(offset)
{
this.register = register;
Variable = variable;
name = variable.OriginalName;
this.type = type;
}
// controlled loading a number into register
// using Toffoli gates
// if controlBits are empty, the number is loaded unconditionally
public static void LoadNumber(this QuantumComputer comp, Register target, ulong number, params RegisterRef[] controlBits)
{
Validate(target, number);
int controlLength = controlBits.Length;
int i = 0;
ulong tmpN = number;
while (tmpN > 0)
{
int rest = (int)(tmpN % 2);
tmpN = tmpN / 2;
if (rest == 1)
{
if (controlLength > 1)
{
comp.Toffoli(target[i], controlBits);
}
else if (controlLength > 0)
{
comp.CNot(target[i], controlBits[0]);
}
else
{
target.SigmaX(i);
}
}
i++;
}
}
// register A - initially loaded with a
// register B - initially loaded with b
// register C - initially 0, exactly one bit wider than A, stores overflow bit
// register N - initially loaded with N
// after computation in register B: (a+b) mod N
// other registers dont change their states
// register B must be exactly one bit wider than A to store carry bit
// register B must be exactly one bit wider than N to store carry bit
// registers A, N must be the same length
// Insecure version: registers widths etc. are not checked
public static void AddModulo(
this QuantumComputer comp,
Register a,
Register b,
Register c,
Register N,
ulong valueN)
{
RegisterRef carry = b[b.Width - 1];
RegisterRef overflow = c[c.Width - 1];
comp.Add(a, b, c);
comp.InverseAdd(N, b, c);
comp.SigmaX(carry);
comp.CNot(overflow, carry);
comp.SigmaX(carry);
//resetting N
comp.LoadNumber(N, valueN, overflow);
comp.Add(N, b, c);
// now we have [(a+b) mod N] in B register
// next steps lead to recover the initial state of registers N and overflow bit
//setting N back
comp.LoadNumber(N, valueN, overflow);
comp.InverseAdd(a, b, c);
comp.CNot(overflow, carry);
comp.Add(a, b, c);
}
/// <summary>
/// Replace all references to oldRegister with newRegister in the given instruction set.
/// </summary>
public void ReplaceRegisterWith(Register oldRegister, Register newRegister, MethodBody body)
{
var oldRegister2 = (oldRegister.Type == RType.Wide) ? body.GetNext(oldRegister) : null;
var newRegister2 = (newRegister.Type == RType.Wide) ? body.GetNext(newRegister) : null;
if (oldRegister.IsKeepWithNext != newRegister.IsKeepWithNext)
throw new ArgumentException("New register has different keep-with-next value");
HashSet<Instruction> list;
if (map.TryGetValue(oldRegister, out list))
{
list.ForEach(x => x.ReplaceRegisterWith(oldRegister, newRegister));
// Update newRegister
AddRange(newRegister, list);
}
if (oldRegister2 != null)
{
if (map.TryGetValue(oldRegister2, out list))
{
list.ForEach(x => x.ReplaceRegisterWith(oldRegister2, newRegister2));
// Update newRegister2
AddRange(newRegister2, list);
}
}
}
// Add(a, b, 0) -> (a, a+b, 0)
// Registers a, b and c must not overlap
// Registers a and b have the same width
// Register c is used for storing carries and must be minimum one bit wider than register a (or b)
// Initial value of c must be 0
public static void Add(this QuantumComputer comp,
Register a, Register b, Register c)
{
if (comp.Group)
{
object[] parameters = new object[] { comp, a, b, c };
comp.AddParametricGate("Add", parameters);
return;
}
else
{
comp.Group = true;
}
int width = a.Width;
int i = 0;
for (; i < width - 1; i++)
{
comp.Carry(c[i], a[i], b[i], c[i + 1]);
}
comp.Carry(c[i], a[i], b[i], b[i + 1]);
comp.CNot(b[i], a[i]);
comp.Sum(c[i], a[i], b[i]);
i--;
for (; i >= 0; i--)
{
comp.InverseCarry(c[i], a[i], b[i], c[i + 1]);
comp.Sum(c[i], a[i], b[i]);
}
}
public static void AddQFTPhi(this QuantumComputer comp, Register a, Register b, params RegisterRef[] controls)
{
if (comp.Group)
{
object[] parameters = new object[] { comp, a, b, controls };
comp.AddParametricGate("AddQFTPhi", parameters);
return;
}
else
{
comp.Group = true;
}
Validate(a, b);
for (int j = b.Width - 1; j >= 0; j--)
{
for (int i = j; i >= 0; i--)
{
List<RegisterRef> list = controls.ToList<RegisterRef>();
list.Add(a[i]);
RegisterRef[] controls2 = list.ToArray();
comp.CPhaseShift(Math.Abs(j-i), b[j], controls2);
}
}
}
public RotateOperation(short _sourceAddress, short _targetAddress, RotationDirection _direction, Register.RegisterFileMap _registerFileMap, short _address)
: base(_registerFileMap, CYCLES, _address)
{
this.data = _registerFileMap.Get(_sourceAddress);
this.targetAddress = _targetAddress;
this.direction = _direction;
}
// register x - initially loaded with x
// register N - initially loaded with N
// control - control bit
// other registers - initially 0
// after computation register B changes and contains: [(a*x) mod N]
// Insecure version: registers widths etc. are not checked
public static void CMultModulo(
this QuantumComputer comp,
Register a,
Register b,
Register c,
Register N,
Register x,
RegisterRef control,
ulong valueA,
ulong valueN)
{
ulong power2 = 1;
for (int i = 0; i < x.Width; i++, power2 *= 2)
{
// loading A register with (2^i * a) mod N
ulong toLoad = (valueA * power2) % valueN;
comp.LoadNumber(a, toLoad, control, x[i]);
// adding [(2^i * a) + B] modulo N
comp.AddModulo(a, b, c, N, valueN);
// unloading [(2^i * a) mod N] from A register
comp.LoadNumber(a, toLoad, control, x[i]);
}
// if control == 0
// then B register contains still 0
// so we copy X register into B register
comp.SigmaX(control);
for (int i = 0; i < x.Width; i++)
{
comp.Toffoli(b[i], control, x[i]);
}
comp.SigmaX(control);
}
public RAM(int width, int registerWidth)
{
registers = new Register[width];
for (int i = 0; i < registers.Length; i++) {
registers[i] = new Register(registerWidth);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UnboxAny"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="result">The result.</param>
/// <param name="instance">The instance.</param>
public UnboxAny(Class type, Register result, Register instance)
: base("UnboxAny", result, new Operand [] { instance })
{
this.type = type;
}
/// <summary> /// Checks if it's <c>EIP</c>/<c>RIP</c> /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsIP(this Register register) => register == Register.EIP || register == Register.RIP;
/// <summary> /// Checks if it's a 512-bit vector register (<c>ZMM0</c>-<c>ZMM31</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsZMM(this Register register) => Register.ZMM0 <= register && register <= IcedConstants.ZMM_last;
/// <summary> /// Checks if it's a test register (<c>TR0</c>-<c>TR7</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsTR(this Register register) => Register.TR0 <= register && register <= Register.TR7;
/// <summary> /// Checks if it's an 8-bit general purpose register (<c>AL</c>-<c>R15L</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsGPR8(this Register register) => Register.AL <= register && register <= Register.R15L;
/// <summary> /// Checks if it's a segment register (<c>ES</c>, <c>CS</c>, <c>SS</c>, <c>DS</c>, <c>FS</c>, <c>GS</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsSegmentRegister(this Register register) => Register.ES <= register && register <= Register.GS;
/// <summary> /// Checks if it's an <c>XMM</c>, <c>YMM</c> or <c>ZMM</c> register /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsVectorRegister(this Register register) => Register.XMM0 <= register && register <= IcedConstants.VMM_last;
/// <summary> /// Checks if it's an MMX register (<c>MM0</c>-<c>MM7</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsMM(this Register register) => Register.MM0 <= register && register <= Register.MM7;
/// <summary> /// Checks if it's a bound register (<c>BND0</c>-<c>BND3</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsBND(this Register register) => Register.BND0 <= register && register <= Register.BND3;
/// <summary> /// Checks if it's an FPU stack register (<c>ST0</c>-<c>ST7</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsST(this Register register) => Register.ST0 <= register && register <= Register.ST7;
/// <summary> /// Checks if it's a control register (<c>CR0</c>-<c>CR15</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsCR(this Register register) => Register.CR0 <= register && register <= Register.CR15;
/// <summary> /// Checks if it's a debug register (<c>DR0</c>-<c>DR15</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsDR(this Register register) => Register.DR0 <= register && register <= Register.DR15;
public static IEnumerable<Instruction> SpillRegister(Register reg, IEnumerable<Instruction> containedInstructions)
{
yield return Instruction.Create(Code.Push_r64, reg);
foreach (var inst in containedInstructions) { yield return inst; }
yield return Instruction.Create(Code.Pop_r64, reg);
}
/// <summary> /// Checks if it's an opmask register (<c>K0</c>-<c>K7</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsK(this Register register) => Register.K0 <= register && register <= Register.K7;
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
Register.JavaScript(Page, @"
$('.helpPanel').click(function () {
var $hp = $(this);
$hp.toggleClass('helpVisible');
});
// hide mce toolbar to prevent it getting skewed
$('.tabs a').click(function () {
$('.mceExternalToolbar').hide();
});
$('input').focus(function () {
$('.mceExternalToolbar').hide();
});
$('.dimmable').n2dimmable();
$('.uploader > label').n2revealer();
$('.expandable').n2expandable({ visible: '.uncontractable' });
$('form').n2expandableBox({ opener: '.rightOpener', opened: '#outside' });
$('#outside .box').n2expandableBox({ opener: 'h4', opened: '.box-inner' });
", ScriptOptions.DocumentReady);
Register.StyleSheet(Page, Url.ResolveTokens("{ManagementUrl}/Resources/Css/edit.css") + "?v=" + Register.CssVersion);
Page.ClientScript.RegisterHiddenField(ClientID + "_autosaved_url", Page.Request[ClientID + "_autosaved_url"] ?? currentItem.ID.ToString());
if (EnableAutoSave)
{
Register.JavaScript(Page, @" window.n2autosave && n2autosave.init();", ScriptOptions.DocumentReady);
TryAddItemReference(this);
foreach (var placeholder in placeholders.Values)
{
if (!TryAddItemReference(placeholder as WebControl))
{
if (placeholder.Controls.Count > 0)
{
TryAddItemReference(placeholder.Controls[0] as WebControl);
}
}
}
}
else
{
TryAddDisabledAutosave(this);
foreach (var placeholder in placeholders.Values)
{
if (!TryAddDisabledAutosave(placeholder as WebControl))
{
if (placeholder.Controls.Count > 0)
{
TryAddDisabledAutosave(placeholder.Controls[0] as WebControl);
}
}
}
}
}
/// <summary> /// Gets the size of the register in bytes /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static int GetSize(this Register register) => register.GetInfo().Size;
public void RegisterTaskPanes(Register register)
{
contentHost.RegisterSelf(register);
}
public override Result Execute()
{
register = new Register(receiver.RegisterUser);
register.BeginInvoke(newUser, callbackMethod, this);
return(new NullResult());
}
/// <summary> /// The register number (index) relative to <see cref="GetBaseRegister(Register)"/>, eg. 0-15, or 0-31, or if 8-bit GPR, 0-19 /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static int GetNumber(this Register register) => register.GetInfo().Number;
private void WriteRegister(Register register)
{
WakeUpDevice();
_i2cDevice.WriteByte((byte)register);
SleepDownDevice();
}
/// <summary> /// Gets the base register, eg. <c>AL</c>, <c>AX</c>, <c>EAX</c>, <c>RAX</c>, <c>MM0</c>, <c>XMM0</c>, <c>YMM0</c>, <c>ZMM0</c>, <c>ES</c> /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static Register GetBaseRegister(this Register register) => register.GetInfo().Base;
/// <summary> /// Gets the full register that this one is a part of, except if it's a GPR in which case the 32-bit register is returned, /// eg. CL/CH/CX/ECX/RCX -> ECX, XMM11/YMM11/ZMM11 -> ZMM11 /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static Register GetFullRegister32(this Register register) => register.GetInfo().FullRegister32;
public static void InverseControlledUaGate(this QuantumComputer comp, ulong a, ulong N, RegisterRef ctrl, Register x, Register reg0, RegisterRef control)
{
if (comp.Group)
{
object[] parameters = new object[] { comp, a, N, ctrl, x, reg0, control };
comp.AddParametricGate("InverseControlledUaGate", parameters);
return;
}
else
{
comp.Group = true;
}
Validate(x, N);
int?invA = Quantum.Utils.InversionModulo((int)a, (int)N);
if (invA == null)
{
throw new ArgumentException("No inversion for specified a");
}
comp.MultModuloQFT((ulong)invA, N, ctrl, x, reg0, control);
comp.Swap(reg0, x, control);
comp.InverseMultModuloQFT(a, N, ctrl, x, reg0, control);
}
protected override void RegisterToolbarSelection()
{
string script = GetToolbarSelectScript("preview");
Register.JavaScript(this, script, ScriptPosition.Bottom, ScriptOptions.ScriptTags);
}
public static void InverseControlledUaGate(this QuantumComputer comp, ulong a, ulong N, Register x, RegisterRef control)
{
if (comp.Group)
{
object[] parameters = new object[] { comp, a, N, x, control };
comp.AddParametricGate("InverseControlledUaGate", parameters);
return;
}
else
{
comp.Group = true;
}
Register ctrl = comp.NewRegister(0, 1);
Register reg0 = comp.NewRegister(0, x.Width);
comp.InverseControlledUaGate(a, N, ctrl, x, reg0, control);
}
private short ReadRegisterInt16(Register register)
{
return(ReadRegisterInt16((byte)register));
}
/// <summary> /// Checks if it's a 32-bit general purpose register (<c>EAX</c>-<c>R15D</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsGPR32(this Register register) => Register.EAX <= register && register <= Register.R15D;
/// <summary> /// Checks if it's a 64-bit general purpose register (<c>RAX</c>-<c>R15</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsGPR64(this Register register) => Register.RAX <= register && register <= Register.R15;
/// <summary> /// Checks if it's a 16-bit general purpose register (<c>AX</c>-<c>R15W</c>) /// </summary> /// <param name="register">Register</param> /// <returns></returns> public static bool IsGPR16(this Register register) => Register.AX <= register && register <= Register.R15W;
/// <summary>
/// Adds an instruction to the end of the code
/// </summary>
/// <param name="command">The instruction's command</param>
/// <param name="register">The instruction's register argument</param>
/// <param name="length">The instruction's length argument</param>
/// <param name="offsetOrValue">The instruction's offset or value argument</param>
public void AddInstruction(OpCode command, Register register, byte length, short offsetOrValue)
{
AddInstruction(new Instruction(command, register, length, offsetOrValue));
}