1. Си / Говнокод #18798

    −95

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    char* _getvalue(....)
    {
       ...
       return("");
    }

    Запостил: schwrzwldr_gbln, 01 Октября 2015

    Комментарии (163) RSS

    • просто чел ещё не понимает что такое char*. прострел ноги у него ещё впереди
      Ответить
      • а что тут не так с char*?
        Ответить
        • char *str = "qwerty";
          str[0] = 'A';
          Ответить
          • тебе вернули строку, а ты её не порти!
            Ответить
            • > тебе вернули строку,
              return "";
              > а ты её не порти!
              const
              Ответить
              • >const
                не каждая сишечка может в const
                Ответить
                • Может этим версиям сишечки уже пора на покой?
                  Ответить
              • ну const там напрашивается, однако компилятор вонинги не выдаёт, да и не помню я, чтобы в стандарте говорилось что-то про обязательность const
                код тупой, но формально ничего не нарушает, поправьте меня
                Ответить
                • В сях разрешено неявное преобразование строковых литералов в char* (без const), в отличии от плюсов.
                  Ответить
                  • Я понимаю, что для совместимости с тем самым говном мамонта... Но зря они это оставили, имхо. Надо было опцию сделать типа -fnonconst-literals и сразу задепрекейтить её. А в каком-нибудь 5.x выпилить её нахуй.

                    P.S. В gcc 3.x вообще литералы можно было править на ходу, если соотв. опцию включить. Слава богу, что в 4.х эту гадость таки решились выпилить.
                    Ответить
                    • От таких выпилов теперь хрен старый hlsdk с gcc скомпилируешь.
                      Чтобы собрать - придётся править однотипные ошибки целый день. Тысячи их. А всё потому что запретили в c++ неявно брать указатель на функции.
                      Ответить
                      • > неявно брать указатель на функции
                        Неявно это как?
                        void foo() {
                        }
                        
                        void (*f)();
                        f = foo; // так? но работает же...
                        > придётся править однотипные ошибки целый день
                        Скриптом не получится?
                        Ответить
                        • Да, примерно так.
                          В плюсах это с новым gcc не работает.
                          Там используются макросы SetThink, SetTouch и т.д, которые присваивают функции.
                          Причём, функция может быть NULL, а сами функции - мемеры классов.
                          И добавление & в макрос не поможет т .к &NULL.
                          Вообще и без скрипта можно - заменить все обращения к NULL на другие макросы и подправить исходные.
                          А от -fpermissive очень сложно избавиться т.к нужно везде имя класса приписать, чтобы код был корректен.
                          Ответить
                          • > это с новым gcc не работает
                            5.2.1 это недостаточно новый? В нём работает без -fpermissive с -Wall -Wextra -std=c++98 -pedantic...

                            Можно пример кода и точную версию gcc?
                            Ответить
                            • Попробую. У меня 4.8. если удастся исправить, это серьёзно упростит портирование модов halflife на linux
                              Ответить
                          • > мемеры классов
                            ISO C++ forbids taking the address of a bound member function to form a pointer to member function. Say ‘&foo::test’ [-fpermissive]

                            Вот эта ошибка что ли?
                            Ответить
                            • Одна из них. Но тут уж только -fpermissive.
                              В новом hlsdk на github исправлены обе ошибки
                              Ответить
                          • Им даже самим стыдно было за эти макросы...
                            // Ugly technique to override base member functions
                            // Normally it's illegal to cast a pointer to a member function of a derived class to a pointer to a 
                            // member function of a base class.  static_cast is a sleezy way around that problem.
                            Ответить
                            • Блин, до меня только сейчас дошёл весь ужас этого кода... Пойду оформлять пост на ГК ;)
                              Ответить
                • гцц варнинги выдает (которые мне таки тест порушили)
                  Ответить
                  • шланг не выдаёт
                    а шланг++ ругается
                    похоже, это действительно для совместимости
                    Ответить
                • в стандарте сказано что за мудификацию строк можно и по еблу получить, потому что компилятор вправе хранить их в таком месте, куда писать (и какать) нельзя.
                  Ответить
                  • >в стандарте сказано что за мудификацию строк можно и по еблу получить
                    В принципе возможен такой UB - компилятор отправляет e-mail своему аффтору, тот приезжает и бьёт ебучку автору кода. Всё по стандарту. UB же.
                    Ответить
                    • Или например прибежит гигантский розовый заяц и откусит голову. Это тоже часть множества UB
                      Ответить
                      • > гигантский розовый заяц и откусит голову
                        Тортик. Кто смотрел - тот понял, о чём я.
                        Ответить
                        • это уже не ub, а qb получается
                          Ответить
                          • Крестовик заключает договор, в обмен на исполнение своего желания, а потом всю жизнь борется с UB'ами на фоне всякого сюрреализма из буста. Рано или поздно кристалл жизни (или как там он правильно назывался) тускнеет и крестовик сам превращается в UB. А Бьярне забирает высвободившуюся энергию...
                            Ответить
                            • А почему все ненавидят кресты?
                              Ответить
                              • Потому что за годы общения с крестами превращаешься в цундере: вроде постоянно ругаешь, а вроде и нравятся.
                                Ответить
                                • а знание аниме обязательно для С++ника?
                                  Ответить
                                  • Ортогонально :3
                                    Ответить
                                    • А умение пропатчить KDE под FreeBSD для анимешника?
                                      Ответить
                                      • KDE давно уже редкость, а фря так и вовсе никому не интересна
                                        Ответить
                                  • Для программиста верно и обратное - начинаешь смотреть аниме и кресты влекут тебя
                                    Ответить
                            • будет ещё великий программист, который перепишет на крестах все сетевые протоколы, от чего весь интернет превратится в UB
                              но всех спасёт известный крестовик-путешественник во времени из известного комикса про изучение C++ за 21 день: сначала он порвёт стандарт крестов, но страуструп сожрёт обрывки стандарта и тут же высрет новый, включающий в себя операторы из APL...
                              конец второй серии
                              Ответить
                              • Надобно отключить себе интернеты и пересмотреть.
                                Ответить
                            • Mahou Shoujo Madoka Magica?
                              Ответить
            • И не удаляй
              Ответить
        • Наверно то что return("") создаст локальную переменную - пустую строку и вернет на нее указатель, при выходе из функции освободит ее память и дальше в ней будет мусор.
          Ответить
          • Нет, "" - статическая питушня, поэтому возвращается всегда одна* и всегда хорошая: http://ideone.com/VjnPt1. Как строка она идеальна.
            Но её нельзя модифицировать, а в обсуждаемой функции она возвращается как char* вместо const char*. Итого: кто-то модифицировал результат, а программа упала. Автора функции забили камнями.
            _______________________________
            * если соответствует одному и тому же** литералу
            ** может и разным одинаковым, если работает соответствующая оптимизация: http://ideone.com/UHBYKm
            Ответить
            • А, возвращается указатель на ридонли память? Еще лучше, человеку только пришедшему на си пытаться понять что такое ридонли сегмент и что например argv модифицировать нельзя и как это понять из сообщения об ошибке.
              Ответить
              • > А, возвращается указатель на ридонли память?
                Хотя это был риторический вопрос,
                да.
                Ответить
                • Смотрите, неизменяемые строки в си!
                  Ответить
                  • Можно и неизменяемые числа запилить: http://ideone.com/rEnaIQ
                    Ответить
                    • на пятизначных и отрицательных облом?
                      Ответить
                      • Для отрицательных 16-битных можно свою функцию написать.
                        На все пятизначные можно расширить.
                        За 32хбитными числами заходите чуть позже.
                        Ответить
                        • >За 32хбитными числами заходите чуть позже.

                          Сделай их платными.
                          Ответить
              • > как это понять из сообщения об ошибке
                access violation at 0xdeadbeef память не может быть write? :)

                Причём если нормальная ось, то ты хоть краш получишь... А вот во всяком embedded там или молча разрешат писать и запорют все аналогичные литералы (если защиты памяти нет), или молча не запишут (если это какая-нибудь труъ r/o флешка).
                Ответить
                • Скорее "программа выполнила невыполнимое, допустила недопустимое" и гадай в чем тут проблема.

                  Во всяком embedded еще нет защищенного режима?
                  Ответить
                  • > защищенного режима
                    А от него даже на x86 толку никакого, если paging не включить. Одно слово "защищённый" :) Можно, конечно, изъябываться с отдельными сегментами под всё подряд и far указателями, но 99% компиляторов уже разучились с ними работать...

                    А на контроллерах - да, даже MPU (memory protection unit, который в отличие от MMU не умеет адреса страничек транслировать, только защищать) и то не везде есть, что уж говорить про полноценный MMU...
                    Ответить
                    • paging эт че?

                      >А на контроллерах
                      А embedded и контроллеры это разве одно и то же? Я думал на всем embedded уже питух или хотя бы vxworks
                      Ответить
                      • > на всем embedded уже питух
                        Не, на те же cortex'ы ты линуху не загонишь... Да и задачи у них не те.

                        > paging
                        Страничная трансляция, или как это по-русски. Короче когда у тебя виртуальная память разбита на странички, к примеру, по 4к. И есть специальные таблицы, в которых для каждой такой странички написано, какой физический адрес ей соответствует (если она не высвопана) и какие ограничения по доступу (user/supervisor, read/write/execute). За счёт этого оси делают изоляцию процессов друг от друга, своп и т.п. Как-то так, если не вдаваться в детали :)
                        Ответить
                        • Самое смешное, что флажок «no execute» не так давно появился, и некоторой софт оказался к нему не готов. Например, чтобы работали трамплины, которые gcc создаёт для замыканий, а также чтобы царский код не тормознулся, приходится стек делать исполнимым, что сильно ударяет по безопасности.

                          Кстати, жаль, что от far отказались, ведь с ними можно было иметь 64 гигабайта виртуальной памяти (вместо четырёх) даже на 32-битных машинах.

                          *****

                          Говорят, что в OS/2 использовалось три кольца защиты, а в Windows почему-то от кольца 2 отказалась, оставив только 3 и 0. Означает ли это, что Windows менее безопасна, чем OS/2?
                          Ответить
                          • Скажи еще x64 недавно появился

                            Windows однозначно менее безопасна потому что на ней есть юзеры, а значит и стимул писать вредоносный софт.
                            Ответить
                          • > иметь 64 гигабайта виртуальной памяти
                            Это как? Там же в защищённом режиме far не такой, как в реалмоде, за 32 бита виртуальной памяти никак не вылезти.

                            > а в Windows почему-то от кольца 2 отказалась, оставив только 3 и 0
                            А в amd64 и от сегментации отказались, оставив только пейджинг...
                            Ответить
                            • А сегментация это что? И чем она отличается от страничной адресации?
                              Ответить
                              • Блин, трудно научно-популярно всю эту низкоуровневую хуиту объяснять...

                                В защищённом режиме адрес транслируется джважды:
                                - из логического (logical) адреса (селектор сегмента + смещение) в линейный (linear)
                                - и из линейного (linear) адреса в физический (physical)

                                Селектор сегмента это, грубо говоря, его номер в табличке с дескрипторами сегментов (их может быть две - GDT и LDT). Каждый дескриптор - это структурка, в которой описано, с какого линейного адреса начинается данный сегмент (base), какого он размера (limit) что с ним можно делать (read/write/execute), кому к нему можно лезть и ещё куча всякой хуиты. Ну соответственно трансляция идёт тупо - ищем в табличке дескриптор, проверяем права и прибавляем смещение к base из дескриптора...

                                Т.е. в теории, сишный указатель у тебя должен состоять из джвух частей - селектора и смещения...

                                Но, на деле, почти все 32-битные операционки юзали эти сегменты очень тупо - выставляли базу в 0, лимит где-нибудь на 2-4 гига, из-за этого linear адрес совпадал с logical, по сути отрубая всю сегментацию нахуй (так называемая flat модель памяти). И компиляторы вообще разучились работать с чем-то кроме этой модели. Поэтому amd, когда запиливало свой 64-битный long mode, тупо выкинуло всю эту сегментацию нахуй, чтобы проц быстрее работал.
                                Ответить
                                • > - и из линейного (linear) адреса в физический (physical)
                                  Забыл написать, что вот эта вторая трансляция - это и есть пейджинг, про который говорили выше.
                                  Ответить
                                  • Ну давай уже расскажи тогда как линейные (которые ваще-то тоже логические) адреса превращаются в физические, как работает MMU, как он использует TLB, как при чтении выгруженной и страницы возникает page fault.

                                    Расскажи как потом часть процессора, ответственная за доступ к памяти выставляет этот адрес и как на него могут отзываться устройства при MMIO и всякие другие ROM, или как на него отвечает контроллер памяти.

                                    Как контроллер выбирает сначала канал, затем ранг и делает ему chip select, как выбирает колонку и ряд, как открываются в банках маленькие кондёры и как падают, в конце концов, заряды на чувствительные усилители.
                                    Ответить
                                    • Читал когда-то это у Зубкова. Кто подскажет что почитать про x64? Или там кроме 64 бита ничего нового?
                                      Ответить
                                      • > Или там кроме 64 бита ничего нового?
                                        Для прикладника там вообще ничего нового, только 64-битность завезли да пачку дополнительных регистров.

                                        Попытались заодно сделать единое соглашение о вызовах, но не проканало. Зато их теперь всего 2 - у майкрософта и у всех остальных.

                                        Ну а для системщика - ещё один уровень в таблице страниц, выпиливание сегментации и быстрые системные вызовы (которые, к слову, интел умудрился неправильно переписать у amd и устроить кроссплатформенное решето сразу в куче операционок и гипервизоров...)
                                        Ответить
                                • Но именно для сегмента/селектора прописываются допустимые операции. Или они убрали base/limit?
                                  Ответить
                                  • > Или они убрали base/limit?
                                    Да, если не вникать в тонкости так и есть. База на нуле, лимит не проверяется. И проверки прав на всём, кроме кодовых сегментов тоже убрали. В 64-битной операционке все права разруливаются на уровне страничек...
                                    Ответить
                                    • А как же запрет исполнения для стека? И рид онли страницы?
                                      Ответить
                                      • > А как же запрет исполнения для стека? И рид онли страницы?
                                        Дык всё это на уровне страниц и разруливается.
                                        Ответить
                                        • А на каком уровне это, пардон разруливалось раньше?
                                          Ответить
                                          • Можно было на уровне сегментов ещё. Но операционки эту фичу один хер не юзали.

                                            А вот NX (бит запрета исполнения странички) появился относительно поздно.
                                            Ответить
                                            • >Можно было на уровне сегментов ещё.
                                              Как? У меня сегменты ассоциируются с реальным режимом.
                                              Ответить
                                              • Сегменты были и в 32х битном режиме тоже, но там их никто не использовал. Все ставили регистры сегментов (DS, CS, вот это все) в 0 и получали одну такую длинную портянку памяти, в которой резвились, как хотели. 20 лет (с изобретения 32битного 386 до изобретения amd x64) сегменты пылились на полке, пока их не выкинули на мороз в x64, потому что зачем лишнее говно-то?
                                                Ответить
                                                • > Все ставили регистры сегментов (DS, CS, вот это все) в 0
                                                  Неправда. В cs, ds и т.п. лежали ненулевые селекторы. Просто у дескрипторов, на которые они указывали, база была выкручена в 0. Ну и регистры fs и gs юзали (и даже на amd64 продолжают юзать) для всяких thread local блоков.
                                                  Ответить
                                                  • Через регистр FS можно сильно поднасрать в служебные таблички Винды...
                                                    Ответить
                                                    • > в служебные таблички Винды
                                                      Дык их только юзермод юзает, а ядро даже не читает (а если читает - то проверяет на 100600 раз)... Разве не так?
                                                      Ответить
                                                  • Ну понятно дело что в протектед моде в сегментном регистре лежала не часть адреса а номер записи в таблице:)

                                                    Я имел ввиду что никто не пользовался реально сегментами так, как то имел ввиду интел в 8086 когда данные лежат в DS, код в CS итд. Все делали как-бы плоскую модель
                                                    Ответить
                                            • >Поддержка данного флага появилась в архитектуре x86 как часть режима PAE (Physical Address Extension) в поколении Pentium 4
                                              Ответить
                                              • >Поддержка данного флага появилась в архитектуре x86 как часть режима PAE (Physical Address Extension) в поколении Pentium 4

                                                «Но операционки эту фичу один хер не юзали.»

                                                В Windows поддержка флага NX появилась только в Висте (под названием DEP), да и то по умолчанию включена только для системных процессов, а пользовательские программы не защищены. Если включить DEP для всех процессов, то заколебёшься добавлять в список исключений программы, написанные Царями, которые так и норовят что-нибудь исполнять в стеке или в данных.
                                                Ответить
                                  • Всё прописывается для странички.
                                    Ответить
                          • Ну так-то для юзер спейса был такой Address Windowing Extensions, который правда никто кроме Exchange и MS SQL не умел.

                            А для кернел спейса был Physical Address Extensions чтобы заюзать хотя бы 36 (или сколько там было) бит адреса. В теории он позволял юзать все 64, но дорожек-то было всего 36. Им тоже редко пользовались.

                            А вообще long mode уже существует 10 почти что лет. Пора бы уже.
                            Ответить
                        • Страничная адресация? Хм, я как-то и не думал что ЗР может без нее быть, привык к хуй86, хуле.

                          >Не, на те же cortex'ы ты линуху не загонишь...
                          Да, но считаются ли микроконтроллеры embedded? В моем понимании это гавно типа домашних рутеров.
                          Ответить
                          • > но считаются ли микроконтроллеры embedded
                            Да вроде как любой проц, встроенный в любую железку (кроме универсальных компов) считается...
                            Ответить
                    • >>А от него даже на x86 толку никакого, если paging не включить. Одно слово "защищённый"

                      В 286м был протектед мод, а пейджинга не было (только сегментная адресация).
                      По этой причине в мире существует 0 программ, которые используют защищенный режим в 286
                      Ответить
                      • Я думал потому что защищенный был но 16 битный.
                        Ответить
                        • Он и был 16-битный...
                          Ответить
                        • 16 бит было не самой дикой проблемой, тем более что он имел доступ аж к целому мегабайту памяти (24 дорожки для адреса памяти).
                          А вот отсутствие пейджинга ставило крест на какой-либо серьезной многозадачности.
                          Ответить
                          • Так а где в нем защита тогда была?
                            Ответить
                            • В двух кольцах. Режим ядра и пользователя. Сегмент имел защиту
                              Ответить
                              • И что он защищал? Т.е. защиту можно было бы сделать и в режиме памяти реального режима (где адрес складывался из сегмента << 16 + смещение)?
                                Ответить
                                • В настоящем реальном режиме (в который процессор включался при старте и в котором работал BIOS) защита не работала. Он полностью (насколько это возможно) имитировал работу 8086.

                                  Но был ещё виртуальный режим, который для приложения выглядел как реальный, а с внешней стороны выглядел как защищённый. В частности, виртуальный режим использовал менеджер памяти EMM (и его заменители типа QEMM), выделяя в памяти «реального режима» окно размером 32 или 64 килобайта, которое по требованию приложений отображал на произвольное окно «защищённого режима». Кстати, досовские программы при запуске из-под Windows работают в виртуальном режиме. В виртуальном режиме можно «защищать» не только память, но и порты ввода-вывода, что и делает Windows, эмулируя для досовского приложения видеокарту.

                                  Был ещё шуточный «нереальный режим», который серьёзными программами не использовался, потому что несовместим с менеджерами памяти: переключаемся в защищённый режим, ставим лимит сегмента равным четырём гигабайтам, переключаемся обратно в реальный режим и имеем доступ ко всей оперативке с помощью инструкций с префиксом размера смещения (адрес получается как (16-битный сегмент << 16) + 32-битное смещение). Естественно, в «нереальном режиме» никакой защиты не было, как и в реальном.
                                  Ответить
                                  • Ага, и какое это имеет отношение к тому что я написал?
                                    Ответить
                                • Если можно - ссылку на книгу / доки.
                                  Ответить
                                  • Если понимаешь английский, то советую "ISA System Architecture (3rd Edition)" а потом сразу "x86 Instruction Set Architecture".

                                    Это мегакрутые книжки
                                    Ответить
                                    • Мне не нужны мегакрутые, мне хотелось бы понять что пытается объяснить борманд (он сам похоже тему не до конца понимает). До этого читал Зубкова.
                                      Ответить
                                      • Я вот не понимаю что ты не понимаешь. Борманд довольно неплохо объясняет, кстати. Мне Зубков не очень нравится, мне нравится Кип. Ирвин "ассемблер для x86".

                                        Крутость книг не в том что они для Гуру, а в том что там ОЧЕНЬ хорошо и внятно разжовано как работает архитектура писи начиная с 8086. Еще там есть годные книги по шинам вроде PCI, USB, PCI-Express итд
                                        Ответить
                                • В реальном режиме не было отдельных колец защиты и не было никакого MMU.

                                  Любая программа имела полный доступ ко всей памяти.
                                  Вот ты говоришь mov по такому-то адресу, и проц реально выставляет такой адрес на шину, и там его ловит контроллер памяти (ну или какая-то другая железяка).

                                  То есть даже в случае некоторой многозадачности (например обработчик прерывания мог считаться другой задачей) ты мог всё всем засрать.

                                  Ну вот я взял, и написал хеллоу ворлд который затер все обработчики прерываний, и даже клавиатура не работает, и нужен ребут.

                                  Все таки в 286 так сделать было нельзя: твой адрес был виртуальным, и его потом MMU переводил в реальный.

                                  Адрес этот указывался в формате сегмент:смещение.

                                  При преобразовании использовалась таблица сегментов, которая была своя для каждого процесса.

                                  Но пейджинга не было, загрузить с диска ничего было нельзя, так что если у тебя одна программа съела 500 килобайт, то другая не может съесть больше чем 500 килобайт.

                                  Операционка (еслиб такая была) должна была за этим следить и выдавать память процессам.

                                  Короче представь что у тебя 32бит режим, но не 4Гб а 1Мб памяти максимум и свап файла нету.

                                  Но это все теория: не было вроде таких операционок
                                  Ответить
                                  • >То есть даже в случае некоторой многозадачности (например обработчик прерывания мог считаться другой задачей) ты мог всё всем засрать.
                                    Ну это понятно, именно из-за это и ушли с доса.

                                    Что есть пейджинг? Дай нормальный термин, хоть на английском. Поддержка виртуальной памяти? Она реализуется каким-то флагом, с которым при обращении к странице процессор генерирует исключение, которое может хватать ось и подгружать нужную страницу.
                                    Ответить
                                    • Paging (страничная адресация) это разбиение памяти на страницы (4К в обычном случае на 32бит x86). Главная прелесть этой адресации в том, что страницу можно выгрузить на диск. Именно потому в пиндуосе своп файл называется pagefile.sys. Именно возможность такой выгрузки дает всем программам 4ГБ (ну ладно, 2-3Гб потому что в верхнюю часть мапятся всякие ядреные либы) в 32 битном режиме. Без этого одна программа может съесть к ебеням весь RAM, а остальным программам придется сосать лапу.
                                      Ответить
                                      • https://ru.wikipedia.org/wiki/Страничная_память ?
                                        Ответить
                                        • Да.
                                          Ответить
                                          • Да - страничная память? Ее не было в 286? А что было?
                                            Ответить
                                            • Только сегментная.
                                              Ответить
                                            • > Да - страничная память?
                                              Да.

                                              > Ее не было в 286?
                                              Нет.

                                              > А что было?
                                              Таблички с дескрипторами сегментов (GDT, насчёт LDT не помню, мож и не было ещё). Причём эти сегменты были маленькие и 16-битные. И из-за совместимости с этим нахуй никому не нужным говном сейчас дескрипторы выглядят как ёбаная каша...
                                              Ответить
                                              • А как без нее работал механизм защиты?

                                                Хуй86 из-за обратной совместимости сам говно, дорогое и раза в 3 менее энергоэффективное, хорошо бы его самого выкинуть нахуй и уйти на risc.
                                                Ответить
                                                • у тебя память как у золотой рыбки что ли?

                                                  механизм защиты работал на уровне сегментов
                                                  Ответить
                                                  • Думаешь в этом блядском цирке тут можно что-то понять? Поэтому я и попросил ссылку.

                                                    И как он работал?
                                                    Ответить
                                                    • > Поэтому я и попросил ссылку.
                                                      http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html

                                                      Сойдёт? Размера не пугайся, там большую часть занимает второй том со списком всех инструкций.
                                                      Ответить
                                                • 3_14dar, иди наэльбрус: http://mcst.ru/
                                                  Ответить
                                                  • >.ru/
                                                    Русня, что ли? Сам туда иди, пидар!

                                                    Там риск или VLIW?
                                                    Ответить
                                                    • И то, и другое. Процессоры на архитектуре «SPARC» (RISC) и на архитектуре «Эльбрус» (VLIW).
                                                      Ответить
                                                • х86 и правда гно, но он дешев как семечки, потому что проивордтся вагонами и потому что под него куча конпеляторов, софта итд
                                                  Ответить
                                                  • >дешев как семечки
                                                    Хуясе. Пека-на-палочке с четырехядерным армом и видюхой с декодером видео за 30 евро бывает.
                                                    С инструментами разработки под армом сейчас тоже вроде все нормально (разве что не знаю как там с оракуловской явой). Проблема разве что в нешвабодном софте - но благодаря конпеляции в байткод и тут все станет лучше, больше проблем с другой осью / тачскрином вместо мыши/клавы / другим разрешением.
                                                    Ответить
                                                • > А как без нее работал механизм защиты?
                                                  А там в дескрипторах тоже были биты, отвечающие за кольцо защиты. Если ты из юзермодной проги попытаешься положить, к примеру, в ds какой-то селектор, предназначенный для ядра, то проц бросит исключение, ядро обработает его и убьёт твою прогу нахуй ;)

                                                  Ну и аналогично с исполняемостью/неисполняемостью. В cs просто невозможно засунуть селектор, у которого в дескрипторе нету флажка про исполняемость и наоборот, в остальные сегментные регистры не лезут селекторы с флажком исполняемости.

                                                  Само собой, юзермоду никто не давал дескриптора, который покрывает GDT. Поэтому сам он там ничего поправить не мог. И сосал хуй, юзая только разрешённые селекторы и, соответственно, куски памяти...
                                                  Ответить
                                                  • Но подожди, один и тот же адрес в сегментной модели памяти можно же получить несколькими комбинациями сегмента/смещения.
                                                    Ответить
                                                    • это НЕ адрес в памяти, это адрес записи в таблице
                                                      Ответить
                                                    • > в сегментной модели памяти
                                                      Ты не путай риалмод и защищённый режим.

                                                      В риалмоде линейный адрес (он же и физический) считается как сегмент*16 + смещение и нету никаких дескрипторных таблиц. Вот тут как раз можно комбинировать как душе угодно: 0xF000 : 0x1000, 0xF100 : 0x0000 и т.п. Этот говнорежим для совместимости есть даже в новейших 64-битных процах...

                                                      В защищённом режиме (даже у 286) уже были дескрипторные таблицы, и линейный адрес считается как GDT[селектор].база + смещение, а потом (если у тебя 386+) проходит страничную трансляцию. Да, тут сегменты тоже могут наложиться друг на друга. Но только если их так описали в таблице (т.е. намеренно).

                                                      В long mode amd64 линейный адрес тупо равен смещению (если инструкция не юзает сегментные регистры fs и gs, у которых таки может быть ненулевая база).
                                                      Ответить
                                                      • >и линейный адрес считается как GDT[селектор].база + смещение,
                                                        >а потом (если у тебя 386+) проходит страничную трансляцию.
                                                        Так в чем разница, блжад? Что такое страничная трансляция? Ссылочку можно?
                                                        Ответить
                                                        • > Так в чем разница, блжад?
                                                          Сегменты произвольной длины, а странички - одинаковой (ну, вернее, одной из 4 доступных).
                                                          Ответить
                                                        • реальный режим: физический адрес есть функция от (сегмент, смещение)
                                                          протектед мод 286: реальный адрес есть функция от (процесс, сегмент, смещение)
                                                          протектед мод 386: реальный адрес есть функция от (процесс, линейный_адрес)
                                                          а линейный_адрес это функция от (процесс, сегмент, смещение).
                                                          Ответить
                                                          • > процесс
                                                            Не запутывай, там же только значения в регистрах учитываются :) А при смене процесса (адресного пространства) просто перезагружаются сегментные регистры и CR3.

                                                            P.S. Да, я знаю про task'и.
                                                            Ответить
                                                            • Проц вообще ничего не знает про процессы, он видит только потоки.
                                                              Ответить
                                                              • > он видит только потоки
                                                                Я тебя расстрою. Потоков он тоже не видит... Это просто такая абстракция в операционках.
                                                                Ответить
                                                              • проц знает про local descriptor table в которой и записаны соответствия сегмента-регистра чему-то другому (адресу реальной памяти в случае сегнметной адресации или записи в пейдж тейбле в случае если еще и пейджинг есть). Эту таблицу ему любезно указывает ОС когда меняет процессы
                                                                Ответить
                                                                • > адресу реальной памяти в случае сегнметной адресации или записи в пейдж тейбле в случае если еще и пейджинг есть
                                                                  Не запутывай его, плиз... У чувака и так крышу сносит от нашей криво переведённой терминологии ;) На русском такие темы лучше вообще не рассматривать.
                                                                  Ответить
                                                                  • а что я не так сказал? Ну да: ..address in physical memory (the one, reported to memory controller) in case of segmented memory (286 protected) or record in __page table__ in case of 386+ protected mode.
                                                                    Ответить
                                                                    • > а что я не так сказал?
                                                                      > record in __page table__
                                                                      Вот это.

                                                                      Запись же ищется в page table по линейному адресу, а не просто хранится в GDT/LDT (как кажется по твоей фразе).
                                                                      Ответить
                                                                  • Если ты не знаешь русскоязычной терминологии это еще не значит что ее нет - поэтому я и отправил тебя за книжками.
                                                                    Ответить
                                                                    • за пивом его еще отправь, ага
                                                                      Ответить
                                                                      • Я б отправил, да он все сам выпьет.
                                                                        Ответить
                                                                        • https://twitter.com/citati_prosto
                                                                          Ответить
                                                                          • 1. К чему? 2. Судя по разному размеру текста - это облако тегов? 3. Можно весь твитор скачать?
                                                                            Ответить
                                                                    • Если ты знаешь русскоязычную терминологию, это ещё не значит, что она нужна (и что она совпадает у авторов всех русскоязычных книжек).
                                                                      Ответить
                                                                    • > отправил тебя за книжками
                                                                      Ну я же дал тебе книжку. Том третий (system programming guide). Глава 3.1 Memory management overview. Там кратко и по теме. А чуть ниже картинка есть, которая называется segmentation and paging. Дальше по тексту подробности.
                                                                      Ответить
                                                          • Дай ссылку на книгу какую-то или статью.подсказываю: зубков.
                                                            Ответить
                                                            • > подсказываю: зубков
                                                              Ну ок, скачал твоего зубкова...

                                                              Глава 10.4 Сегментная адресация
                                                              Глава 10.6 Страничная адресация

                                                              Сам не мог открыть содержание? :)
                                                              Ответить
                                                              • Я его даже в бумажной форме читал. Давным давно. А тебе я его дал чтобы ты указал, что в двойке есть, а чего нет вместо того чтобы ты придумывал свои термины.
                                                                Ответить
                                                        • > Ссылочку можно?
                                                          Блин, не могу найти нормальную статью, чтобы с нуля понятно было и с картинками... Запилить что ли себе блог, да попробовать объяснить всю эту питушню понятным языком...
                                                          Ответить
                                                          • Да найди нужные куски в любой книге.
                                                            Ответить
                                                            • А в рот тебе жеваной морковки не положить?

                                                              Нельзя объяснить кусок какой-то концепции с середины если ты не знаешь начала и конца. Читай про архитектуру 8086 с самого начала, хочешь Зубкова, хочешь Юрова, хочешь Ирвина, хочешь вообще Гука. Это тебе не PHPMyAdmin, тут в двух словах не объяснишь
                                                              Ответить
                                                              • Я читал, блжадь. http://govnokod.ru/18798#comment303657
                                                                Ответить
                                                                • Ты злой, неблагодарный хам. Не буду больше тебе помогать. Пускай с тобой Борманд нянчится.
                                                                  Ответить
                                                                  • > Пускай с тобой Борманд нянчится.
                                                                    А борманд пойдёт в Hyperdevotion Noire играться.
                                                                    Ответить
                                                                  • Твои попытки помочь еще не значат что ты чем-то помог. Хочешь помочь - укажи место в книге, до их авторов ты еще не дорос.
                                                                    Ответить
                                  • > Любая программа имела полный доступ ко всей памяти.
                                    Аж ко всему МЕГАБАЙТУ!
                                    Ответить
      • просто не все ещё понимают что такое С.
        прострел ноги у сишников всегда впереди
        Ответить
        • > прострел ноги у сишников всегда впереди
          Но матёрому сишнику пуля не наносит урона, потому что пролетает через разработанное годами отверстие.
          Ответить
          • >потому что пролетает через разработанное годами отверстие
            Пошловатенько звучит. была разработана настолько, что без труда могла вместить любой access violation
            Будем считать что ноги сишников напоминают решето.
            Ответить
          • - А это что у тебя? В ноги ебешься что ли?
            - Нет, я сишник
            - Ясно. Лучше бы ты в ноги ебался - такие сишники нам не нужны
            Ответить

    Добавить комментарий