コード例 #1
0
        /// <summary>
        /// Lowers LFA operations into an adapted version.
        /// </summary>
        protected static void Lower(
            RewriterContext context,
            TypeLowering <TType> typeConverter,
            LoadFieldAddress lfa)
        {
            // Compute the new span
            var span     = typeConverter.ComputeSpan(lfa, lfa.FieldSpan);
            var newValue = context.Builder.CreateLoadFieldAddress(
                lfa.Location,
                lfa.Source,
                span);

            context.ReplaceAndRemove(lfa, newValue);
        }
コード例 #2
0
        /// <summary>
        /// Lowers set field operations into separate SSA values.
        /// </summary>
        protected static void Lower(
            RewriterContext context,
            TypeLowering <TType> typeConverter,
            SetField setValue)
        {
            var builder  = context.Builder;
            var location = setValue.Location;

            // Compute the new base index
            var span = typeConverter.ComputeSpan(setValue, setValue.FieldSpan);

            // Check whether we have to insert multiple elements
            Value targetValue = setValue.ObjectValue;

            if (typeConverter[setValue] is TType)
            {
                for (int i = 0; i < span.Span; ++i)
                {
                    var viewField = builder.CreateGetField(
                        location,
                        setValue.Value,
                        new FieldSpan(i));
                    targetValue = builder.CreateSetField(
                        location,
                        targetValue,
                        new FieldSpan(span.Index + i),
                        viewField);
                }
            }
            else
            {
                // Simple field access
                targetValue = builder.CreateSetField(
                    location,
                    targetValue,
                    span,
                    setValue.Value);
            }
            context.ReplaceAndRemove(setValue, targetValue);
        }
コード例 #3
0
        /// <summary>
        /// Lowers set field operations into separate SSA values.
        /// </summary>
        protected static void Lower(
            RewriterContext context,
            TypeLowering <TType> typeConverter,
            GetField getValue)
        {
            var builder  = context.Builder;
            var location = getValue.Location;

            // Compute the new base index
            var span = typeConverter.ComputeSpan(getValue, getValue.FieldSpan);

            // Check whether we have to extract a nested type implementation
            Value newValue;

            if (typeConverter[getValue] is TType)
            {
                // We have to extract multiple elements from this structure
                var instance = builder.CreateDynamicStructure(location, span.Span);
                for (int i = 0; i < span.Span; ++i)
                {
                    var viewField = builder.CreateGetField(
                        location,
                        getValue.ObjectValue,
                        new FieldSpan(span.Index + i));
                    instance.Add(viewField);
                }
                newValue = instance.Seal();
            }
            else
            {
                // Simple field access
                newValue = builder.CreateGetField(
                    location,
                    getValue.ObjectValue,
                    span);
            }
            context.ReplaceAndRemove(getValue, newValue);
        }